delirios de rayohauno

Linear Algebra Libraries - n.2

2011-05-22T16:51:00.009-03:00

In a previous post I discuss some some options about linear algebra libraries. Especifically I'm looking for a tool to eigenvalue (and maybe eigenvectors) calculation. In the previous post I have mentioned Eigen which is a (free) C++ template library so is easily to "install" (just copy the files somewhere) and use (just include the headers). With Eigen you can calculate eigenvalues (and eigenvectors), and is very easily (intuitive) to use. So Eigen is very appropriate for prototyping some program that requires linear algebra tools at some point. The people that develop Eigen says that Eigen is very fast (in some cases even fastest that other non template libraries). But I think (I have not tested it yet) that Eigen may be fast in basic linear algebra operations. In the case of eigenvalue problems it gives to me the sensation that is slow. So I'm looking for an alternative to it, and found about CULA, which basically is an implementation of LAPACK for GPGPU (graphic cards accelerators)
.
I'm just very new about this. I have several questions.

1) In my laptop I think that I do not have a GPGPU card. So: ¿I will need to work directly with the machines of the cluster where I work (machines that have a GPGPU card on it)? ¿Are there some kind of GPGPU simulator?2) ¿What need to be installed and how do you install it in order to start doing some trials with CULA?3) ¿Does CUDA need to be installed also?
In order to answer this questions, in the getting started section of the CULA home page one can find some relevant info. It seems that CUDA need to be installed, and also a (nvidia) GPGPU card is needed.

I think that, as CULA is a GPGPU implementation of LAPACK, maybe I can use LAPACK on my program in the laptop, and then, with relative ease adapt the code to run CULA. So, maybe, starting a try with LAPACK will be useful in the first place. Also playing with LAPACK will give to me an idea of the performance of Eigen.

Here I found that it seems not so much directly to use LAPACK from a C++ code.

Here another example of using LAPACK from C++ code.

Here another example of using LAPACK from C++. I like the style of this blog.

So, it seems that deal with LAPACK is a "crap". But I remember that Armadillo may be a convenient way of using LAPACK from C++ (but it will not serve to the purpose of learning LAPACK in order to after learn CULA). Note that Armadillo not necesarilty requires LAPACK and some BLAS library. But Armadillo can be linked to LAPACK (and some BLAS library) in order to achieve better performance and bigger functionality.

The latest version of LAPACK is 3.3.1, but my ubuntu comes with version 3.2.1 previously installed, so I will try first without installing the latest version of LAPACK. On the other hand, for the BLAS support, my ubuntu hasn't got installed ATLAS. F...k, here says that the installation process of ATLAS is a f...ng crap. It says that it may take several hours.

TODO ... finish this.

Salut !

Learning - BGL and property map

2011-04-21T13:58:00.004-03:00

So, when reading about BGL I found difficult to grasp the idea behind property maps. Luckily, in this post there is a nice series of questions and answers that helps to clarify the matter.

Here, another post that shows some simple examples about property map's on graphs.

In this post, it is discussed about a compressed graph representation for static graphs. Here the corresponding link to the BGL home page.

Salut !

R statistics - Dendrograms in R

2011-04-14T21:22:00.003-03:00

The idea here, is to explore how to plot dendrograms using R.

For the moment I just will put a list of links:

http://addictedtor.free.fr/graphiques/RGraphGallery.php?graph=79
http://rwiki.sciviews.org/doku.php?id=rdoc:stats:dendrogram

Keywords :

dendrogram
heatmap
hclust

Salut !

Buying a netbook 2011

2011-04-06T11:14:00.000-03:00

So, I'm planning to buy a netbook.

I had an offer in a local store that ask for $2285 for a BGH MT10. In mercadolibrethere is an offer about $2199 (se here). It seems a nicemachine.

Also, here one can see that it has a relatively nice processor (for being a netbook).

Salut !

Resources - Complex Systems

2011-03-27T18:04:00.004-03:00

Here a list of resources about Complex Systems and Complexity.

: Institutions, Organizations

:: Complexity-NET
York Centre for Complex Systems Analysis
Bristol Centre for Complexity Sciences
Institute of complex system symulation (ICSS)
Warwick Complexity Science Doctoral Training Center
Santa Fe Institute
Center for the study of complex systems
Brooking Center on Social Dynamics and Policy
Northwestern University on Complex System
Nederlantse Organizatie voor Wetenschappelijk Onderzoek
IFISC (españa)
Reseau National des Systemes Complexes (Francia)
Agent Based Computational Economics and Financial Modelling (Essex University)
Complexity and Networks Group (Imperial College, London)

: Blogs

:: Nirkmukta (Promoting Science and Free Thought in India) - COMPLEXITY EXPLAINED

: Books

:: Cosmic Evolution: The Rise of Complexity in Nature - Eric J. Chaisson

Salut !

Neural Networks - Resources

2011-03-20T02:04:00.001-03:00

So, as maybe neural networks will be one of the topics in which I will work in, I use this post to collect resources about neural networks.

sources of answers to FAQs about NN

monthly posting to the Usenet newsgroup comp.ai.neural-nets

databases

Face Recognition Home Page

Salut !

Numerical integration methods of ODEs - n.1

2011-03-18T18:23:00.002-03:00

So, in this post, I will collect information about methods for numerical integration of ODEs (ordinary differential equations).

For the moment, I'm not looking for something very precise, but it is preferred some method that can deals with stability and stiff problems.
A list of links:

First order ordinary differential equations
QUAM- A novel algorithm for the numerical integration of stiff ordinary differential equations (In this "paper" there is a definition of stiffness)

What is stability and stiffness?

: Stiffness

A problem is stiff if its jacobian matrix has at least one eigenvalue with a large magnitude and a wide spread of eigenvalue magnitudes. (source here)

: Stability

TODO ...

Salut !

Resources on web tools

2011-03-10T22:26:00.001-03:00

This post is dedicated to list web tools.

Joomla (see here)
dropbox (see here)
4share
zotero

TODO ... classify the content of this post.

Salut !

Linear algebra libraries - C++

2011-03-06T21:22:00.010-03:00

So, in this post, the idea is to write a little about linear algebra libraries, and the possibility of use them in C++. In this post I pick an important number of "names" related to linear algebra libraries (I need to improve the list with GPGPU possibilities).

So, the "root" seems to be LAPACK (Linear Algebra PACKage) and BLAS (Basic Linear Algebra Subprograms). In fact, LAPACK is the successor of the combination of LINPACK (linear equations, least-squares, etc...) and EISPACK (eigenvalues, eigenvectors, etc ...). LAPACK depends on (make uses of) BLAS in order to effectively exploit the caches on modern cache-based architectures.

BLAS can be used by itself as a way of doing basic linear matrix operations (like matrix multiplication). In fact, there are several highly optimized implementations of the BLAS interface have been developed by hardware vendors such as Intel (see here) and AMD (see here), as well as by other authors, e.g. Goto BLAS and ATLAS (I'm a little bit confused here, because it seems that this options provides more than BLAS, for example, ATLAS provides some LAPACK functions, etc.).

LAPACK is originally written in FORTRAN 77 (and now is also written in FORTRAN 90). As is stated in the Wiki (LAPACK), there are some options that allows the usage of LAPACK from C++. Probably the main options are:

LAPACK++
Armadillo (C++ Library)

(I pick the following info from LAPACK++ on facebook) LAPACK++ seems to be the official way, but Armadillo seems to be newer. The original LAPACK++ (up to v1.1a) was written by R. Pozo et al. at the University of Tennessee and Oak Ridge National Laboratory. In 2000, R. Pozo et al. left the project, with the projects' web page stating LAPACK++ would be superseded by the Template Numerical Toolkit (TNT). The current LAPACK++ (versions 1.9 onwards) started off as a fork from the original LAPACK++. There are extensive fixes and changes, such as more wrapper functions for LAPACK and BLAS routines.

So, I don't know which is the official (LAPACK++ or TNT). Here (in the new official page of LAPACK++)is said that the project TNT never really took off.

There still remains to know if Armadillo is best option than LAPACK++ or not. Due to its approach, Armadillo is related to the uBLAS library, but has a more accessible syntax. Furthermore, as Armadillo has an efficient wrapper of ATLAS and LAPACK functions, it provides machine-dependent optimisations and functionality not present in uBLAS (a template implementation of BLAS in the Boost C++ Library).

Also, there is an important option not mentioned yet. This is Eigen, which is a template library so there is not need of installation (just copy the headers in some path and include them in your C++ code). TNT is also a template library. The template libraries frequently are slower than the precompiled (¿?) implementations, but Eigen seems to be very fast (See here for a comparison benchmark. Just Hessenber (the one that I used to calculate eigenvalues) seems to be a bit slow). Also here says that Eigen is fast for basics matrix operations but slower (than for example uding ATLAS) when more complex operations (for example LU decomposition) are required.

MTL is also a template library, but (as stated here) this does not support (directly) the calculation of eigenvalues. MTL is a kind of (better ¿?) uBLAS.

In the end, I must say that Eigen seems to be a nice option (it is a template library, so I only need to copy the headers), but Armadillo is a good option too (but I have to install it) because it relies on LAPACK which is extensively tested and developed, so there are a lot of available functionalities. I think I will try first (if I need it) with Eigen, and then with Armadillo. Maybe this post could be useful.

I ask myself which one (Eigen or Armadillo) is best suited to the Boost Graph Library (conversion of matrix to graph and vice-versa). Note also that Armadillo is available on R (see here).

Here you can read about how you can solve eigenvalues problems with LAPACK.

Salut !

Analysis - Clustering Coefficient calculation on BGL - n.3

2011-03-01T14:34:00.016-03:00

In a previous post I implement the calculation of the clustering coefficient in a C++ program that uses the BGL. This implementation uses the functions provided in boost/graph/clustering_coefficient.hpp. In this post, I will implement an algorithm proposed (by me, but surely I'm not its inventor) in this other previous post.

So, before the implementation of the code I need to discuss some things. Notice that the algorithm requires that each edge carries a flag that states if it was already visited or not. So part of the problem is how to implement this flags using boost.

So, how to implement that each visited edge carry a flag? So, the main (an appropriate) option seems to be using property maps. It seems that there are two "ways" that property maps can be used: Interior properties and Exterior properties. In this case I need to use Exterior properties because I pass to the function (that calculates Cc) a graph that no contains the flags property in the nodes (I think this is the best, interior properties are only "useful" if they participates trough the process of graph construction). So, how do I use exterior properties by mean of property maps?

When trying to understand how to attach properties to graphs, vertex and edges, at first sight there is some confusion (at least to me), because there are several "things" with similar names and it is not clear which is the role that each of this things play. here (in the section Adding Some Color to your Graph) is a simple explanation of what is and (expect to do...) does each thing. I will follow its lines...

So, in first place there are internally stored properties and externally stored properties for graphs, vertex, and edges "objects". The former are created when the object is created and has the same life span that the object. The later can be attached and removed at any time in the life span of the object. So the former is internally stored in the object, and the later is stored externally.

BGL uses a uniform mechanism to access both kinds of properties inside its graph algorithms called the property map interface, described in Section Property Map Concepts. In addition, the PropertyGraph concept defines the interface for obtaining a property map object for an internally stored property.

In this case, the idea is to use externally stored properties, because my intention is to eventually build graph trough some algorithm and then, only at the end to attach properties to its components (vertex and edges).

The BGL adjacency_list class (see also here) allows users to specify internally stored properties through plug-in template parameters of the graph class. How to do this is discussed in detail in Section Internal Properties.

Externally stored properties can be created in many different ways, although they are ultimately passed as separate arguments to the graph algorithms. One straightforward way to store properties is to create an array indexed by vertex or edge index. In the adjacency_list with vecS specified for the VertexList template parameter, vertices are automatically assigned indices, which can be accessed via the property map for the vertex_index_t. Edges are not automatically assigned indices. However the property mechanism can be used to attach indices to the edges which can be used to index into other externally stored properties.

Remarks and Questions: So it seems that the idea when "building" external properties to vertex (or edges) is to "build" vectors an access its "elements" trough indices attached to each vertex (or edge) by mean of an (internally?) property that must be initialized (except in the case that the VertexList is of type vecS, so then the vertex_index property is initialized automatically (this is (I think) because each vecS element has an index by default)).

In the case of "my algorithm" for the calculation of $Cc$, the flags are properties of the edges. As (it seems that) the edges does not has automatically initialized edge_index's, I must to provide this tho the Graph definition (Is this the case?).

TODO... solve this questions. For that matter I'm reading The Boost Graph Library - User Guide and Reference Manual (I'm going by pag. 51)

So, finally I implemented something that work. It is not "perfect" (it has a lot of naive things that can be easily improved) but it works. The important thing here is that I have implemented my algorithm, it works, and I learned (at least basically) to implement internal and external properties.

What I have done has four files: main.cpp, main.h, cc.hpp, edge_indexing.hpp (I'm still does not known when is appropriate to use .h or .hpp). The first is the main program where the graph is constructed. The second is a simple header that assist the first. The third contains the main functions that are used to calculate the clustering coefficient. The fourth provides a function that "initializes" (set to countable numbers) the edge_index property.

Here are the files:

/**
 * @file main.cpp
 * @author --
 * @email --
 * @date $(Date)
 * @brief Program that uses the BGL to calculate the Clustering
 * Coefficient by a own implementation of a own algorithm.
 **/
 
#include "main.h"

/**
 * \brief This is the main program function
 * \param argc
 * \param argv
 * \return 0
 */

int main(int argc, char **argv)
{

cout << "List of: (vertex_index,Cc_{vertex_index})" << endl;

// create a typedef for the Graph type
//typedef adjacency_list<vecS, vecS, undirectedS> Graph;
typedef property<edge_index_t, std::size_t> EdgeIndexProperty;
typedef adjacency_list<vecS, vecS, undirectedS, no_property, EdgeIndexProperty> Graph;

// Make convenient labels for the vertices
enum { A, B, C, D, E, N };
const int num_vertices = N;
const char* name = "ABCDE";

// writing out the edges in the graph
typedef std::pair<int, int> Edge;
Edge edge_array[] = 
{ Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
  Edge(C,E), Edge(B,D), Edge(D,E) };
const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

// declare a graph object
Graph g(num_vertices);

// add the edges to the graph object
for (std::size_t i = 0; i < num_edges; ++i)
  add_edge(edge_array[i].first, edge_array[i].second, g);    

// add the index to the edges
set_edge_index(g);

// get the property map for vertex indices
typedef property_map<Graph, vertex_index_t>::type IndexMap;
IndexMap index = get(vertex_index, g);

// print the list of: ( vertex_index , Cc_{vertex_index} )
typedef graph_traits<Graph>::vertex_iterator vertex_iter;
pair<vertex_iter, vertex_iter> vp;
for (vp = vertices(g); vp.first != vp.second; ++vp.first) {
  //cout << "vertex = " << index[*vp.first] <<  ", Cc = " << clustering_coefficient(g,*vp.first) << std::endl;        
  cout << "(" << index[*vp.first] <<  "," << clustering_coefficient(g,*vp.first) << ")";          
}
cout << std::endl;

return 0;
}

and

/**
 * @file main.h
 * @author --
 * @email --
 * @date $(Date)
 * @brief Simple header that assist main.cpp
 **/
 
#ifndef MAIN_H
#define MAIN_HPP

#include <iostream>                  // for std::cout
#include <utility>                   // for std::pair
#include <algorithm>                 // for std::for_each
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include "cc.hpp"
#include "edge_indexing.hpp"

//#include <boost/graph/properties.hpp>

using namespace std;  
using namespace boost;

#endif

and


/**
 * @file main.h
 * @author --
 * @email --
 * @date $(Date)
 * @brief This file is intended to write a small program that
 * that uses the BGL to calculate the Clustering
 * Coefficient by a own implementation of a own algorithm.
 * 
 * In particular in this file I implement my own algorithm.
 * 
 * I start by imititating most of /boost/graph/clustering_coefficient.hpp
 * 
 * NOTE: 
 *  - In this first try it will only support undirected graphs.
 *  - One thing that can be improved is the usage of the bool edge flag.
 * 
**/

#ifndef CC_HPP
#define CC_HPP

#include <iostream>                  // for std::cout
#include <utility>                   // for std::pair
#include <algorithm>                 // for std::for_each
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>

//#include <boost/utility.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graph_concepts.hpp>
#include <boost/graph/lookup_edge.hpp>  

//#include <boost/graph/properties.hpp>

namespace boost
{

namespace detail
{

template <class Graph>
inline typename graph_traits<Graph>::degree_size_type
possible_edges(const Graph& g, std::size_t k, directed_tag)
{
    function_requires< GraphConcept<Graph> >();
    typedef typename graph_traits<Graph>::degree_size_type T;
    return T(k) * (T(k) - 1);
}

template <class Graph>
inline typename graph_traits<Graph>::degree_size_type
possible_edges(const Graph& g, size_t k, undirected_tag)
{
    // dirty little trick...
    return possible_edges(g, k, directed_tag()) / 2;
}

// This template matches directedS and bidirectionalS.
template <class Graph>
inline typename graph_traits<Graph>::degree_size_type
count_edges(const Graph& g,
            typename graph_traits<Graph>::vertex_descriptor u,
            typename graph_traits<Graph>::vertex_descriptor v,
            directed_tag)

{
    function_requires< AdjacencyMatrixConcept<Graph> >();
    return (lookup_edge(u, v, g).second ? 1 : 0) +
            (lookup_edge(v, u, g).second ? 1 : 0);
}

// This template matches undirectedS
template <class Graph>
inline typename graph_traits<Graph>::degree_size_type
count_edges(const Graph& g,
            typename graph_traits<Graph>::vertex_descriptor u,
            typename graph_traits<Graph>::vertex_descriptor v,
            undirected_tag)
{
    function_requires< AdjacencyMatrixConcept<Graph> >();
    return lookup_edge(u, v, g).second ? 1 : 0;
}
} /* namespace detail */

template <typename Graph, typename Vertex>
inline typename graph_traits<Graph>::degree_size_type
num_paths_through_vertex(const Graph& g, Vertex v)
{
function_requires< AdjacencyGraphConcept<Graph> >();
typedef typename graph_traits<Graph>::directed_category Directed;
typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;

// TODO: There should actually be a set of neighborhood functions
// for things like this (num_neighbors() would be great).

AdjacencyIterator i, end;
boost::tie(i, end) = adjacent_vertices(v, g);
std::size_t k = std::distance(i, end);
return detail::possible_edges(g, k, Directed());
}

/*
* This is the function that I need to modify.
*/
template <typename Graph, typename Vertex>
inline typename graph_traits<Graph>::degree_size_type
num_triangles_on_vertex(const Graph& g, Vertex v, undirected_tag)
{
function_requires< IncidenceGraphConcept<Graph> >();
function_requires< AdjacencyGraphConcept<Graph> >();
typedef typename graph_traits<Graph>::degree_size_type Degree;

// bool flag external edge property
/* Notice that I'm calculating the Cc of just one vertex, and
 * the following vector is created (and destroyed) each time.
 * This is not the best way of doing this. The best way is to
 * create this just once, and then pass it as an argument by reference
 * to this function. For simplicity I choose this way.
 * Also, notice that the clustering coefficient can only be calculated
 * to undirected graphs.
 */
std::vector<bool> edge_flag(num_edges(g));

// get the property map for edge indices
typedef typename property_map<Graph, edge_index_t>::const_type edgeindex_map_t;
edgeindex_map_t edgeindex_map = get(edge_index,g);

// set flags to false of the edges of the neighbors of v
typedef typename graph_traits<Graph>::adjacency_iterator adj_iter;
std::pair<adj_iter,adj_iter> vip;

typedef typename graph_traits<Graph>::out_edge_iterator out_edge_iter;
std::pair<out_edge_iter,out_edge_iter> eip;

for(vip=adjacent_vertices(v,g);vip.first!=vip.second;++vip.first){
    for(eip=out_edges(*vip.first,g);eip.first!=eip.second;++eip.first){
        edge_flag[edgeindex_map(*eip.first)] = false;
    }
}

// count the number of times that the edges of the neighbors of v are visited more than once
Degree count(0);
for(vip=adjacent_vertices(v,g);vip.first!=vip.second;++vip.first){
    for(eip=out_edges(*vip.first,g);eip.first!=eip.second;++eip.first){
        if(edge_flag[edgeindex_map(*eip.first)] == true){
            count++;
        }else{
            edge_flag[edgeindex_map(*eip.first)] = true;    
        }
    }
}

// return "that" number
return count;
}

template <typename T, typename Graph, typename Vertex>
inline T
clustering_coefficient(const Graph& g, Vertex v)
{
typedef typename graph_traits<Graph>::directed_category Directed;
T zero(0);
T routes = T(num_paths_through_vertex(g, v));
return (routes > zero) ?
    T(num_triangles_on_vertex(g, v, Directed())) / routes : zero;
}

template <typename Graph, typename Vertex>
inline double
clustering_coefficient(const Graph& g, Vertex v)
{ return clustering_coefficient<double>(g, v); }

} /* namespace boost */

#endif

and finally:

/**
 * @file edge_indexing.hpp
 * @author --
 * @email --
 * @date $(Date)
 * @brief Here is provided a function that set the edge index
 **/

#ifndef EDGE_INDEXING_H
#define EDGE_INDEXING_HPP

//#include <iostream>                  // for std::cout
#include <utility>                   // for std::pair
//#include <algorithm>                 // for std::for_each
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>

//#include <boost/graph/properties.hpp>

using namespace std;  
using namespace boost;

template<typename Graph>
void set_edge_index(Graph& g)
{
    typedef typename property_map<Graph, edge_index_t>::type edgeindex_map_t;
    edgeindex_map_t edgeindex_map = get(edge_index,g);

    typedef typename graph_traits<Graph>::edge_iterator edge_iter;
    std::pair<edge_iter,edge_iter> eip;

    typedef typename property_map<Graph, edge_index_t >::type EdgeIndexPropertyMap;
    typedef typename property_traits<EdgeIndexPropertyMap>::value_type EdgeIndexPropertyValue;
    EdgeIndexPropertyValue n=0;
    for(eip=edges(g);eip.first!=eip.second;++eip.first){
        put(edgeindex_map,*eip.first,n++);
    }
}

#endif

The program works as can be seen (look previous post to check that the numbers are right):

$ ./CcInBGL_ownAlgo 
List of: (vertex_index,Cc_{vertex_index})
(0,0.666667)(1,1)(2,0.666667)(3,0.5)(4,1)

Salut !

Analysis - Clustering Coefficient calculation on BGL - n.2

2011-03-01T10:59:00.001-03:00

Now, in this post (following a previous post) Firstly, will try to make a simple program that uses the standard implementation of the calculation of the clustering coefficient in the BGL, secondly I will try to implement the algorithm that I propose (at the end of the previous post).

So, I start a new project in Codelite, with the following files:

/*
 * filename: main.cpp
 * 
 * Program that uses the BGL to calculate the Clustering
 * Coefficient of the nodes of a Graph.
 * 
 */
#include "main.h"

int main(int argc, char **argv)
{
    
    cout << "List of: (vertex_index,Cc_{vertex_index})" << endl;
    
    // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, undirectedS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] = 
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);    
    
    // get the property map for vertex indices
    typedef property_map<Graph, vertex_index_t>::type IndexMap;
    IndexMap index = get(vertex_index, g);
    
    // print the list of: ( vertex_index , Cc_{vertex_index} )
    typedef graph_traits<Graph>::vertex_iterator vertex_iter;
    pair<vertex_iter, vertex_iter> vp;
    for (vp = vertices(g); vp.first != vp.second; ++vp.first) {
      cout << "(" << index[*vp.first] <<  "," << clustering_coefficient(g,*vp.first) << ") ";        
    }

    cout << std::endl;    

    return 0;
}

and:

/*
 * filename: main.h
 * 
 * This file is intended to write a small program that
 * uses BGL to calculate the Clustering Coefficient.
 * 
 */
 
#ifndef MAIN_H
#define MAIN_HPP
 
  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/clustering_coefficient.hpp>
  
  using namespace std;  
  using namespace boost;
    
#endif

The graph that it implements is this:

When I tried to compile the program, it returns an error, boost/graph/clustering_coefficient.hpp is not in the boost C++ library that my ubuntu installed. So, I have a boost C++ library downloaded from here (in fact, from there I will to here and downloaded boost_1_46_0.zip, the uncompressed it in a directory), and pass to the compiler the option:

-I/home/my_user/some_extra_path/boost_1_46_0/

and then it compiled right. Then I run the program and obtain:

List of: (vertex_index,Cc_{vertex_index})
(0,0.666667) (1,1) (2,0.666667) (3,0.5) (4,1)

so it works right. In the next post I will try "my" algorithm to calculate the clustering coefficient.

Salut !

Analysis - Clustering Coefficient calculation on BGL - n.1

2011-02-28T17:09:00.015-03:00

Analysis is a series of post that works as an auxiliary to other posts. In this case I want to analyze the algorithm that calculates the clustering coefficient (the local version of Watts-Strogatz) of the node of a graph that is implemented on the BGL.

So, I will not enter fully into the details of the code that has to do with the Boost C++ way of coding. Instead I want to analyze the "essential" structure of the algorithm. I will consider only the "directed graph version" of this algorithm. In what follows n is the numberof nodes and d is the "typical" degree. So counting the neighbors of a node is of Complexity O(d), and so on...

There is a function named clustering_coefficient(g,v) that takes as arguments a graph g and a node v, its pseudo code is:

// Pseudo code
double clustering_coefficient(g,v) {
  return triangles_on_vertex(g,v) / num_paths_trough_vertex(g,v)
}

so, it calls two other functions. The first is:

// Pseudo code
int num_paths_trough_vertex(g,v) {
   iterators ini,end;
   tie(ini,end) = adjacent_vertices(g,v)
   k = std::distance(ini,end); // Complexity: O(1) constant time 
                               // if adjacent_vertices
                               // is a container as 
                               // vector<>. Linear 
                               // time O(d) if it is
                               // a container as list.
   return k*(k-1);   
}

The second is:

// Pseudo code
// Cycling in the two nested loops is of Complexity O(d^2) if
// inside it there are something of constant Complexity O(1).
// But, inside it, there is something of Complexity O(d), so
// the total Complexity (of the function) is O(d^3).
//
int num_triangles_on_vertex(g,v) {
   iterators i,j,end;
   int count = 0
   for( tie(i,end) = adjacent_vertices(g,v) ; i!=end ; i++ ) {
      for ( j = next(i) ; j!=end ; j++ ) {
         count += num_edges(g,*i,*j); // This returns 1 
                                      // iff vertexs *i and *j
                                      // are connected, 0 in o.c.
                                      // Complexity: Constant 
                                      // time O(1) if 
                                      // graph is like and 
                                      // adjacency matrix. 
                                      // Linear time O(d) if graph 
                                      // is like 
                                      // adjacency list.
      }
   }
   return count;
}

so, in this implementation, in the case of a graph represented by an adjacency list the Complexity for the calculation of the Clustering Coefficient of a node is order O(d^3).
Is there an efficient way? In the following papers I found that there is a way that uses matrix multiplication to determine the Clustering Coefficient of each node of the graph:

Approximating clustering-coefficient and transitivity, Schank, T. and Wagner, D., (2004)
Finding and counting given length cycles, Alon, N. and Yuster, R. and Zwick, U., (1997)

In particular, in the first paper (of this short list) provides a cheaper way to estimate the Clustering Coefficient. The efficiency of the matrix multiplication method is of Complexity $O(m^{\frac{2\gamma}{(\gamma+1)}})$, where $m$ is the number of links of the network, and $\gamma \simeq 1.5$.

I was thinking in the following possibility. If one iterates trough the neighbors $j$ of a node $i$, and for each $j$ one iterates for its adjacent edges. Then, it happens that some edges will be visited one time (the edges that connect a neighbor of $i$ with a node non neighbor of $i$), and others visited two times (the edges that connect two neighbors of $i$). The number of edges visited two times is $T_i$, and then:

$Cc_i = \frac{T_i}{\frac{k_i(k_i-1)}{2}}$
(note that in the iteration trough the adjacent edges one also iterates trough the edges that goes from the neighbors of $i$ to $i$ itself, but those edges are visited just only one time so they do not are counted in $T_i$). So, in this way one can calculate $Cc_i$ on Complexity $\bigO(d^2)$ (essentially the same Complexity that is calculated $T_i$). So, the problem now is how to implement this, but this is a problem that I will treat in a following post.

Salut !

Algorithms, data structures, libraries

2011-02-28T12:19:00.040-03:00

In this post, the idea, is to list several algorithms (data structures) useful for some purpose. The algorithms (data structures) may be in "plain" text description, or maybe implemented in some particular platform (language). The list of algorithms (data structures) will be separated by titles that specify the "goals" of those algorithms (data structures).

Before keep going, what is a data structure (to me)? Well, take for example a graph, there are several ways of represent a graph in a computer, for example, the adjacency matrix, or the adjacencies lists. So, here, besides algorithms also I will list "data structures".

Also, I will list links to sites where one can found algorithms, codes, etc.

: Algorithms
:: Graph/Networks
::: Clustering Coefficient
:::: In BGL there is a file inside boost/graph/ named clustering_coefficient.hpp. In this post I analyze the efficiency of the implementation.

: Libraries (or sources of code)
:: General
::: Boost C++
::: GSL (GNU Scientific Library)
::: Numerical Recipes
::: MATLAB file exchange
::: C++ Libraries
::: TNT (Template Numerical Toolkit)
::: Netlib Repository
::: NIST (National Institute of Standards and Technology)
::: NHSE
::: codecogs (code for engineers)
:: Graph/Networks
::: NGraph
::: Lemon Graph Library
::: Igraph
:: Linear Algebra
::: LAPACK
::: LAPACK++ (old LAPACK++)
::: ARPACK
::: NAPACK
::: PLAPACK (parallel LAPACK)
::: ScaLAPACK (also parallel LAPACK)
::: EISPACK
::: UMFPACK
::: BLAS
::: uBLAS
::: ATLAS
::: TNT
::: Armadillo C++
::: FLAME (Or libflame. Seems to support GPU)
::: Eigen
::: Gmm++
::: MTL
::: MKL
::: FLENS
::: Blitz++ (it also serves for more than linear algebra)
::: IT++ (it also serves for more than linear algebra)
:::: Useful posts or articles
::::: Lapackpp vs Boost BLAS (check answers, some one give a general view)
::::: Linear Algebra Benchmarks
::::: Discussion about possibilities
::::: More benchmarks
::::: FREELY AVAILABLE SOFTWARE FOR LINEAR ALGEBRA ON THE WEB (April 2009)
::::: How expensive is it to compute the eigenvalues of a matrix?
::::: Basic linear algebra sub programs on Wiki (overview of possibilities)
::::: Scientific Computing / Linear Algebra Library Survey
:: Miscelaneous
::: Karypis Lab

:Very general sources (algorithms, papers, libraries, code, etc...)
:: All Web Hunt, Computer Algoritmhs
:: Algorithms and Complexity Resources

Salut !

Interesting Libraries on Boost C++ Libraries

2011-02-28T00:14:00.002-03:00

Here I will posting the list of interesting (to me) libraries on the Boost C++ Libraries

Accumulators: Useful to calculate statistical quantities as means or variances, etc...
Random: Pseudo-random number generators.
foreach: this may easy coding in the Boost C++ Libraries
Generic Image Library
Math/Statistical distributions
Parsing

Salut !

Complexity - Bibliography

2011-02-26T15:52:00.025-03:00

So I wan't to collect bibliography about Complexity in this post. I will also "repost" some bibliography previously posted in this blog, now with the advantage of the usage of tags.

The J. P. Crutchfield approach:

Structure or Noise? (2007), Talk (2008)
Optimal Causal Inference: Estimating Stored Information and Approximating Causal Architecture (2007-2010)
Information theoretic approach to interactive learning (S. Still, 2007-2009)
Prediction, Retrodiction, and The Amount of Information Stored in the Present (2009)
How many clusters? An information theoretic perspective (S. Still, 2003)
Time's Barbed Arrow: Irreversibility, Crypticity, and Stored Information (2009)
Information Accessibility and Cryptic Processes (2009)
Information Accessibility and Cryptic Processes: Linear Combinations of Causal States (2009)
The Organization of Intrinsic Computation: Complexity-Entropy Diagrams and the Diversity of Natural Information Processing (2008)
Synchronization and Control in Intrinsic and Designed Computation: An Information-Theoretic Analysis of Competing Models of Stochastic Computation (2010)Computational Mechanics: Pattern and Prediction, Structure and Simplicity (2000)
Quantifying Self-Organization with Optimal Predictors (2004)
Quantifying Self-Organization in Cyclic Cellular Automata (2005)
An Algorithm for Pattern Discovery in Time Series (2002)
Blind Construction of Optimal Nonlinear Recursive Predictors for Discrete Sequences (2004)
Causal architecture, complexity and self-organization in time series and cellular automata (thesis of C.R.Shalizi, 2001)
Computational mechanics of cellular automata: An example (1997)
Computational Mechanics of Classical Spin Systems (Feldman thesis, 1998)
Discovering Noncritical Organization: Statistical Mechanical, Information Theoretical, and Computational Views of Patterns in One-Dimensional Spin Systems (1998)
Inferring statistical complexity (1989)
Measures of statistical complexity: Why? (1995)
A measure of statistical complexity based on predictive information (Abdallah, Plumbey ,2010)
Optimal Nonlinear Prediction of Random Fields on Networks (2003)
Reductions of Hidden Information Sources (2004)
Regularities unseen, randomness observed: Levels of entropy convergence (2001)
The calculi of emergence: computation, dynamics and induction (1994)
Thermodynamic depth of causal states: Objective complexity via minimal representations (1994)
What Is a Macrostate? Subjective Observations and Objective Dynamics (2003)
Statistical Complexity of Simple 1D Spin Systems (1997)
The Past and the Future in the Present (2010)
Synchronization and Control in Intrinsic and Designed Computation: An Information-Theoretic Analysis of Competing Models of Stochastic Computation (2010)
Structural Drift: The Population Dynamics of Sequential Learning (2010)
Objects That Make Objects: The Population Dynamics of Structural Complexity (2004)
Many Roads to Synchrony: Natural Time Scales and Their Algorithms (2010)
How the Dimension of Space Affects the Products of Pre-Biotic Evolution: The Spatial Population Dynamics of Structural Complexity and The Emergence of Membranes (2010)
Exact Synchronization for Finite-State Sources (2010)
Enumerating Finitary Processes (2010)
Asymptotic Synchronization for Finite-State Sources (2010-2011)
Hierarchical Self-Organization in the Finitary Process Soup (2006)
Primordial Evolution in the Finitary Process Soup (2007)
Many Roads to Synchrony: Natural Time Scales and Their Algorithms (2010)
Order and Disorder on Open Systems (2010)
Synchronization and Control in Intrinsic and Designed Computation: An Information-Theoretic Analysis of Competing Models of Stochastic Computation (2010)
Optimal Instruments and Models for Noisy Chaos (2007)
Inferring Markov Chains: Bayesian Estimation, Model Comparison, Entropy Rate, and Out-of-class Modeling (2007)
How Random is a Coin Toss? Bayesian Inference and the Symbolic Dynamics of Deterministic Chaos (2006)
Persistent Chaos in High Dimensions (2005)
Automated Pattern Detection--An Algorithm for Constructing Optimally Synchronizing Multi-Regular Language Filters (2004)
Synchronizing to Periodicity: The Transient Information and Synchronization Time of Periodic Sequences (2002)
Synchronizing to the Environment: Information Theoretic Constraints on Agent Learning (2001)
Information Bottlenecks, Causal States, and Statistical Relevance Bases: How to Represent Relevant Information in Memoryless Transduction (2000)
Pattern Discovery and Computational Mechanics (2000)

Useful links:

Jim Crutchfield Complexity Science Center at UCDavids (here it is all its bibliography)
Santa Fe institute, query=Crutchfield
Jim Crutchfield's Research Communications
List of Publications: David P. Feldman
http://www.citeulike.org/user/dpf/author/Crutchfield:JP

Salut !

Computational Resources - BGL on the GTMC

2011-02-25T18:03:00.003-03:00

In a previous post I fond that BGL is not installed on bandurria (a computer cluster at GTMC). So now I have to see for a solution. One (plausible) solution involves to ask the cluster maintainer to install BGL on the cluster. Other (plausible) solution is to install BGL in my home dir.

So, how I do that? This is the reason of this post.

Now, it seems that the installation of BGL is system dependent. That is, BGL is installed in different ways in different systems. For example, check this post (there, it seems that the owner of the blog install the Boost C++ library, not only BGL).

So, the first question is. Which kind of system is bandurria? It is a cluster, so I don't know exactly how the files are shared there. As far I know, one has access to every node, but in practice one only need access to the "main" node of the cluster. In fact, when one login into bandurria, the filesystem that one can see is the filesystem of the "main" node-computer of the group (that is, pulga).

So, in my first try, I will appeal to the fact that BGL is (except some exceptions) basically a header only library, so it is (in principle) not system dependent. So, I go here and from there I go here and downloaded boost_1_46_0.zip (notice that I have downloaded all the boost library, not only BGL). Then I copy that file to a temporary directory on bandurria where I plan to try the example programs that uses BGL. I unzip the library inside that temporary directory and a new directory named boost_1_46_0 was created. inside it there is a directory named boost/ which contains the library.

So, I simply do the following whit the same example used in the previous post
, I compile via:

g++ -I/home/myusername/tmp/boost_1_46_0/ main.cpp 
In file included from main.cpp:8:
main.h:70:3: warning: no newline at end of file
[myusername@bandurria tmp]$ ls
a.out  boost_1_46_0  boost_1_46_0.zip  main.cpp  main.h
[perotti@bandurria tmp]$ ./a.out 
hello world BGL
vertices(g) = 0 1 2 3 4 
edges(g) = (0,1) (0,3) (2,0) (3,2) (2,4) (1,3) (3,4) 
adjacent structure of vertex: 0
out-edges: (0,1) (0,3) 
in-edges: (2,0) 
adjacent vertices: 1 3 
adjacent structure of vertex: 1
out-edges: (1,3) 
in-edges: (0,1) 
adjacent vertices: 3 
adjacent structure of vertex: 2
out-edges: (2,0) (2,4) 
in-edges: (3,2) 
adjacent vertices: 0 4 
adjacent structure of vertex: 3
out-edges: (3,2) (3,4) 
in-edges: (0,3) (1,3) 
adjacent vertices: 2 4 
adjacent structure of vertex: 4
out-edges: 
in-edges: (2,4) (3,4) 
adjacent vertices:

so, it works.

Salut !

Computational Resources - Checking if I can run programs developed in my machine in the GTMC computers/clusters

2011-02-25T12:03:00.006-03:00

In order to try to answer some questions of this post I will try to run some programs developed in Codelite, in the computers/clusters at my disposition in GTMC.

So, my first trying step is to write a simple(basic) program in Codelite, make an executable from it, and then run it in (for example) jote. So, I made a simple hello world program in codelite:

/*
 * Simple hello world program
 * 
 * Note that it includes the header stdio.h
 */
 
#include <stdio.h>

int main(int argc, char **argv)
{
    printf("hello world\n");
    return 0;
}

Then build it. Inside the project directory (named basicprogram) there is a directory named Debug/, inside it there is an executable file named basicprogram (so it seems that the executable acquires the project name). The I copied it inside jote (into a tmp directory), and try tu run it:

$ ./basicprogram  
-bash: ./basicprogram: cannot execute binary file

so, this simple hello world program does not work. Is this because the inclusion of the stdio.h header? Lets look what happens if I do not include it. So I modify the program:

/*
 * filename: main.cpp
 *
 * Simple hello world program
 * 
 * Note that now the inclusion of stdio.h is commented
 */
 
//#include <stdio.h>

int main(int argc, char **argv)
{
//    printf("hello world\n");
    int j=0;
    return j;
}

and it also does not work. So, it seems that the code need to be compiled on the target machine.

What happens if I compile that code using simply my g++ ubuntu compiler? It also doesn't work.

TODO: Ask to the computers maintainers if there is (and which one, g++, gcc, etc) a C++ compiler installed on the computers.

Nice... g++ is installed in bandurria, and a simple Hello World program can be compiled and run there. What about a program that uses STL o BGL?

TODO: Answer this question.

The following program uses STL:

/*
 * filename: main.cpp
 *
 * This program objective is to see if code that uses STL
 * can be compiled in the clusters of GTMC, in particular
 * in bandurria.
 * 
 */

/*
 * This kind of including does not work on my system.
 */
//#include <string.h>
//#include <algo.h>
//#include <vector.h>
//#include <stdlib.h>
//#include <iostream.h>

/*
 * This kind of including does work on my system.
 */
#include <string.h>
#include <algorithm>
#include <vector>
#include <stdlib.h>
#include <iostream>

main ()
{
  using namespace std;
    
  vector<int> v;  // create an empty vector of integers
  int input;
  while (cin >> input)    // while not end of file (press ctrl-D on my system to EOF)
    v.push_back (input);  // append to vector
 
  // sort takes two random iterators, and sorts the elements between 
  // them.  As is always the case in STL, this includes the value
  // referred to by first but not the one referred to by last; indeed,
  // this is often the past-the-end value, and is therefore not
  // dereferenceable.
  sort(v.begin(), v.end());
 
  int n = v.size();
  for (int i = 0; i < n; i++)
    cout << v[i] << "\n";
}

it compiled and run on my system, and also if I copied main.cpp into bandurria I also can compile and run it. So, STL exists in bandurria, and is included in the same way (as far as I can see from this example) that I do that on my system. Now (again), what about BGL?, lets try with it. So I try a simple project in Codelite that involves two files:

/*
 * filename: main.cpp
 * 
 * This file is intended to write a small program that
 * uses BGL.
 * 
 */
#include "main.h"

int main(int argc, char **argv)
{
    using namespace std;
    
    cout << "hello world BGL" << endl;
    
    // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] = 
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);

    // get the property map for vertex indices
    typedef property_map<Graph, vertex_index_t>::type IndexMap;
    IndexMap index = get(vertex_index, g);

    // accessing the vertex set
    std::cout << "vertices(g) = ";
    typedef graph_traits<Graph>::vertex_iterator vertex_iter;
    std::pair<vertex_iter, vertex_iter> vp;
    for (vp = vertices(g); vp.first != vp.second; ++vp.first)
      std::cout << index[*vp.first] <<  " ";
    std::cout << std::endl;

    // accessing the edge set
    std::cout << "edges(g) = ";
    graph_traits<Graph>::edge_iterator ei, ei_end;
    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        std::cout << "(" << index[source(*ei, g)] 
                  << "," << index[target(*ei, g)] << ") ";
    std::cout << std::endl;

    // the adjacency structure
    std::for_each(vertices(g).first, vertices(g).second,
                  exercise_vertex<Graph>(g));

    return 0;
}

and:

/*
 * filename: main.h
 * 
 * This file is intended to write a small program that
 * uses BGL.
 * 
 */
  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/dijkstra_shortest_paths.hpp>

  using namespace boost;

  template <class Graph> struct exercise_vertex {
    // the functor
    exercise_vertex(Graph& g_) : g(g_) {}

    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;

    // vertex descriptor
    void operator()(const Vertex& v) const
    {
      typedef graph_traits<Graph> GraphTraits;
      typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);

      // which vertex
      std::cout << "adjacent structure of vertex: " << index[v] << std::endl;

      // out edges
      std::cout << "out-edges: ";
      typename GraphTraits::out_edge_iterator out_i, out_end;
      typename GraphTraits::edge_descriptor e;
      for (tie(out_i, out_end) = out_edges(v, g); 
           out_i != out_end; ++out_i) {
        e = *out_i;
        Vertex src = source(e, g), targ = target(e, g);
        std::cout << "(" << index[src] << "," 
                  << index[targ] << ") ";
      }
      std::cout << std::endl;

      // in edges
      std::cout << "in-edges: ";
      typename GraphTraits::in_edge_iterator in_i, in_end;
      for (tie(in_i, in_end) = in_edges(v,g); 
           in_i != in_end; ++in_i) {
        e = *in_i;
        Vertex src = source(e, g), targ = target(e, g);
        std::cout << "(" << index[src] << "," << index[targ] << ") ";
      }
      std::cout << std::endl;

      // adjacent vertices (notice that it only returns the vertex that are targets of out edges of vertex v)
      std::cout << "adjacent vertices: ";
      typename GraphTraits::adjacency_iterator ai;
      typename GraphTraits::adjacency_iterator ai_end;
      for (tie(ai, ai_end) = adjacent_vertices(v, g); ai != ai_end; ++ai)
        std::cout << index[*ai] <<  " ";
      std::cout << std::endl;

      // ...

    }

    Graph& g;
  };

and it works on my system, but it does not compile in bandurria. Seems that BGL is not there. So, now I have two (plaussible) directions. One is to install BGL on my home in bandurria, the other is to ask Banchio to install it in the system.

TODO: Solve this problem.

Salut !

Computational resources - Clusters and computers at my disposition

2011-02-25T11:51:00.004-03:00

This post is dedicated to "my relationship" with the clusters at the GTMC group in FaMAF. Some time ago I had used some computer with 8 nodes of the Grupo de Relatividad at FaMAF. The name of the computer is Manguruyu.I know that there are other clusters in the UNC, but I don't have much more information (plausible contact: Christian Sanchez at the Facultad de Quimica).

So, at GTMC (my main option) there are two clusters of computers:

Deep Bluee II
Bandurria

Also there are some isolated machines that I can access to to run programs. They are:

tero (a core i7 with 6 or 8 nodes)
jote
lince (maybe soon with GPGPU)
lechuza (maybe)

Now, I know that most of them has an Intel Fortran compiler. I don't know if they have some C++ compiler. I believe that some of them has some version of R installed (but, I'm not sure, and I don't know which one is/are).

So, a list of TODO things:

TODO: Check which computers/clusters have some C++ compiler and which one (g++, or gcc, etc).
TODO: Check which computer (maybe cluster) has R (and which version).
TODO: Determine in which computers is best to install R.

Also some questions came to my mind. If I develop C++ progrmas in codelite (in my machine), then:

How then I run them in the clusters?
I compile in my machine and copy the executables to the clusters?
Or is best to compiler the programs directly on the clusters?
The programs that where originally developed in codelite, are easy to compile in the clusters (or in other machine that does not have Codelite installed)?

Salut !

News - Programming Languages

2011-02-24T21:43:00.004-03:00

The new C++ standard is comming:C++0x at WikiOne of it virtues is to improve/facilitate the "usage" of generic programming (that one that uses concepts as in for example STL)Una de las virtudes, es mejorar/facilitar el uso de "generic programming".

Here a video:

Concepts Extending C++ Templates For Generic Programming (google video)

Here is the (some) official page about ConecptGCC (Generic programming trough concepts) that is provided in the talk of the video:

http://www.generic-programming.org/software/ConceptGCC/

Here a good source of information about C++0x.

Wow, as mentionated here, it seems that after all, concepts will not be part of C++0x, it seems that the committee decided to postpone the inclusion of concepts to a later version (eg. C++1x).

Salut !

System manteinance

2011-02-24T19:33:00.001-03:00

This days when ubuntu start up a window appears. It says:

Apt Authentication issueProblem during package list update. The package list update failed with a authentication failure. This usually happens behind a network proxy server. Please try to click on the "Run this action now" button to correct the problem or update the list manually by running Update Manager and clicking on "Check".

So, I click on a button that says "Run this action now", and then another windows appears inwhich the following message can be read:

W: A error occurred during the signature verification. The repository is not updated and the previous index files will be used.GPG error: http://cran-r.c3sl.ufpr.br karmic/ Release: The following signatures couldn't be verified because the public key is not available: NO_PUBKEY 51716619E084DAB9

W: Failed to fetch http://cran-r.c3sl.ufpr.br/bin/linux/ubuntu/karmic/Release

So, it has to do with CRAN. What this problem mean? And, how I can solve it?

Salut !

IDEs - Codelite n.2 - C++, R, Rcpp, BGL

2011-02-24T14:52:00.011-03:00

In a previous post I managed to build a project in Codelite that buid as a C++ project and also from it I can build a R package that uses Rcpp. Now, I will go further and try to add some difficulty to it. I will incorporate BGL code into it.

So as in the previous post I start by opening a R console from Codelite and write:

> require(Rcpp)
Loading required package: Rcpp
> Rcpp.package.skeleton("codeliteRcppBgl")
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './codeliteRcppBgl/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world

so, inside the same workspace directory as in the previous post (Codelite starts in the same workspace that I was working in the previous post) I have created a Rcpp source package namedcodeliteRcppBgl.

Now, I tried to create a new project with the same name (inside the actual workspace) of the type "Simple executable g++" and I get the following message:

The File 'main.cpp' already exists at the target directory '/home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace'
Please select a different project path
The file 'main.cpp' is part of the template project [Simple executable (g++)]

I choose not to overwrite. So, it seems that this is not the right way of using workspaces and projects. So I deleted the source package (from a linux terminal), close the actual working space and create a new one. Inside the new workspace directory I created again the Rcpp source package. The I created inside the workspace a project (of the type "Simple executable g++") with the same name as the Rcpp source package.

Now I incorporate the files of the Rcpp source package into the project. That is, I incorporatercpp_hello_world.cpp, rcpp_hello_world.h, and rcpp_hello_world.R (the last one codelite recognizes it as a simple plain text file). Inside rcpp_hello_world.h there is:

#ifndef _codeliteRcppBgl_RCPP_HELLO_WORLD_H
#define _codeliteRcppBgl_RCPP_HELLO_WORLD_H

#include <Rcpp.h>

/*
 * note : RcppExport is an alias to `extern "C"` defined by Rcpp.
 *
 * It gives C calling convention to the rcpp_hello_world function so that 
 * it can be called from .Call in R. Otherwise, the C++ compiler mangles the 
 * name of the function and .Call can't find it.
 *
 * It is only useful to use RcppExport when the function is intended to be called
 * by .Call. See the thread http://thread.gmane.org/gmane.comp.lang.r.rcpp/649/focus=672
 * on Rcpp-devel for a misuse of RcppExport
 */
RcppExport SEXP rcpp_hello_world() ;

#endif

So I modify it into (by following ideas that I had previously done here):

#ifndef _codeliteRcppBgl_RCPP_HELLO_WORLD_H
#define _codeliteRcppBgl_RCPP_HELLO_WORLD_H

#include <Rcpp.h>

  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/dijkstra_shortest_paths.hpp>

/*
 * note : RcppExport is an alias to `extern "C"` defined by Rcpp.
 *
 * It gives C calling convention to the rcpp_hello_world function so that 
 * it can be called from .Call in R. Otherwise, the C++ compiler mangles the 
 * name of the function and .Call can't find it.
 *
 * It is only useful to use RcppExport when the function is intended to be called
 * by .Call. See the thread http://thread.gmane.org/gmane.comp.lang.r.rcpp/649/focus=672
 * on Rcpp-devel for a misuse of RcppExport
 */
RcppExport SEXP rcpp_hello_world() ;

using namespace boost;

  template <class Graph> struct exercise_vertex {
    // the functor
    exercise_vertex(Graph& g_) : g(g_) {}

    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;

    // vertex descriptor
    void operator()(const Vertex& v) const
    {
      typedef graph_traits<Graph> GraphTraits;
      typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);

      // which vertex
//      std::cout << "adjacent structure of vertex: " << index[v] << std::endl;
        Rprintf("adjacent structure of vertex: %d \n");

      // out edges
      std::cout << "out-edges: ";
      typename GraphTraits::out_edge_iterator out_i, out_end;
      typename GraphTraits::edge_descriptor e;
      for (tie(out_i, out_end) = out_edges(v, g); 
           out_i != out_end; ++out_i) {
        e = *out_i;
        Vertex src = source(e, g), targ = target(e, g);
//        std::cout << "(" << index[src] << "," 
//                  << index[targ] << ") ";
        Rprintf("(%d,%d)",index[src],index[targ]);
      }
//      std::cout << std::endl;
        Rprintf("\n");

      // in edges
//      std::cout << "in-edges: ";
        Rprintf("in-edged: ");
      typename GraphTraits::in_edge_iterator in_i, in_end;
      for (tie(in_i, in_end) = in_edges(v,g); 
           in_i != in_end; ++in_i) {
        e = *in_i;
        Vertex src = source(e, g), targ = target(e, g);
//        std::cout << "(" << index[src] << "," << index[targ] << ") ";
        Rprintf("(%d,%d)",index[src],index[targ]);
      }
//      std::cout << std::endl;
        Rprintf("\n");

      // adjacent vertices (notice that it only returns the vertex that are targets of out edges of vertex v)
      std::cout << "adjacent vertices: ";
      typename GraphTraits::adjacency_iterator ai;
      typename GraphTraits::adjacency_iterator ai_end;
      for (tie(ai, ai_end) = adjacent_vertices(v, g); ai != ai_end; ++ai){
//        std::cout << index[*ai] <<  " ";  
        Rprintf("%d",index[*ai]);
      }
//      std::cout << std::endl;
    Rprintf("\n");

      // ...

    }

    Graph& g;
  };

#endif

And modifiy rcpp_hello_world.cpp from:

#include "rcpp_hello_world.h"

SEXP rcpp_hello_world(){
    using namespace Rcpp ;
    
    CharacterVector x = CharacterVector::create( "foo", "bar" )  ;
    NumericVector y   = NumericVector::create( 0.0, 1.0 ) ;
    List z            = List::create( x, y ) ;

    return z ;
}

into:

#include "rcpp_hello_world.h"

SEXP rcpp_hello_world(){
    using namespace Rcpp ;
    
    CharacterVector x = CharacterVector::create( "foo", "bar" )  ;
    NumericVector y   = NumericVector::create( 0.0, 1.0 ) ;
    List z            = List::create( x, y ) ;

 // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] = 
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);

    // get the property map for vertex indices
    typedef property_map<Graph, vertex_index_t>::type IndexMap;
    IndexMap index = get(vertex_index, g);

    // accessing the vertex set
    std::cout << "vertices(g) = ";
    typedef graph_traits<Graph>::vertex_iterator vertex_iter;
    std::pair<vertex_iter, vertex_iter> vp;
    for (vp = vertices(g); vp.first != vp.second; ++vp.first)
      std::cout << index[*vp.first] <<  " ";
    std::cout << std::endl;

    // accessing the edge set
    std::cout << "edges(g) = ";
    graph_traits<Graph>::edge_iterator ei, ei_end;
    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        std::cout << "(" << index[source(*ei, g)] 
                  << "," << index[target(*ei, g)] << ") ";
    std::cout << std::endl;

    // the adjacency structure
    std::for_each(vertices(g).first, vertices(g).second,exercise_vertex<Graph>(g));

    return wrap("fin") ;
}

Then I installed the source package via clicking the Codelite Extension tool button that I previously incorporate into Codelite (see here). And then (also from Codelite via another Extension tool button) I open a R console and run:

> require("codeliteRcppBgl")
Loading required package: codeliteRcppBgl
Loading required package: Rcpp
> rcpp_hello_world()
vertices(g) = 0 1 2 3 4 
edges(g) = (0,1) (0,3) (2,0) (3,2) (2,4) (1,3) (3,4) 
adjacent structure of vertex: 0 
out-edges: (0,1) (0,3) 
in-edged: (2,0) 
adjacent vertices: 1 3 
adjacent structure of vertex: 1 
out-edges: (1,3) 
in-edged: (0,1) 
adjacent vertices: 3 
adjacent structure of vertex: 2 
out-edges: (2,0) (2,4) 
in-edged: (3,2) 
adjacent vertices: 0 4 
adjacent structure of vertex: 3 
out-edges: (3,2) (3,4) 
in-edged: (0,3) (1,3) 
adjacent vertices: 2 4 
adjacent structure of vertex: 4 
out-edges: 
in-edged: (2,4) (3,4) 
adjacent vertices: 
[1] "fin"

So, it works nice !!!. Notice that it will not compilate as a C++ project inside Codelite. In fact, as I call "Rprintf()" in the template definition of the struct exercise_vertex inside rcpp_hello_world.h I think it will not work, even if I made all the header and library inclusions in the codelite call to the g++ compiler, because I imagine that Rprintf() only works in a R console.

Notice, that in the (template) code that I write in rcpp_hello_world.h I call Rprintf() to print in screen. But (by mistake) in the code inside rcpp_hello_world.cpp I use cout to print on screen and it works !!! But, this is not recommended (I read some time).

TODO: Try to compile this as a C++ Codelite project.

Salut !

IDEs - Codelite n.1

2011-02-22T10:02:00.014-03:00

I'm just installed Codelite to give it a try. It is mainly developed to work with C/C++. But as can be seen here (video example) you can extend Codelite with external tools. Maybe this is a way to integrate some R functionality into Codelite.

Now I have a problem. In the video example above the user incorporate external tools via menu:Pluggins -> External tools -> Configure external tools. But in my installed version of Codelite there exist Pluggins but it does not have External tools. So I go to synaptic (I'm on ubuntu) and search for codelite-pluggins-externaltools and installed it.

Now I try to follow the video in order to try to "install" a R console. So I do the following:

1) I create a new External tool that opens a ubuntu gnome-terminal. The only thing that worth to mention is that in the field Path I write gnome-terminal (so this is the command that it will execute and will open a ubuntu console). Also in the field Working directory I go to help and copy $(ProjectPath) (at least for the moment). Finally I "pick" the icons from /usr/share/icons/gnome/...

Then I create another External tool to open a R console. The things that worth to mention are. In the field Path I write gnome-terminal, and in the field Arguments I write -e R (so it opens a ubuntu terminal and run from it R). In the field Working directory I write $(ProjectPath) (you can choose predeterimated options from the help button in the pop up window). Finally I create adecuate R icons in format .png and save it under /usr/share/icons/R/ then I pick them.

Now the idea is to create a Project from one can deal with a R source package. So in this first attempt I do the following. So, first one must to create a (codelite)workspace and inside it the (codelite)projects. So I create a workspace that requires a working directory. Then I open a R console (from codelite) and do:

> require("Rcpp")
Loading required package: Rcpp
> Rcpp.package.skeleton("codelitepkg")
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './codelitepkg/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world
> dir()
[1] "codelitepkg"                         
[2] "codelite-workspace.tags"             
[3] "codelite-workspace.workspace"        
[4] "codelite-workspace.workspace.session"

so as one can see, I create a R (Rcpp) source package inside the workspace directory. Then I create a project named codelitepkg (the same name as the R source package). Inside it there appears a virtual directory named src. I create two other virtual directories inside the project, one named R and the other Rsrc. Inside R I incorporate the rcpp_hello_world.R file inside the codelitepkg/R/ R source package directory (that it becomes created when I create the source package via the R console trough the command Rcpp.package.skeleton("codelitepkg")). Analogously, inside Rsrc I incorporate the rcpp_hello_world.cpp file inside codelitepkg/src/.

Now there remains to "complete the environment" with the addecuate External tools. So I create a new External tool that Install a R source package. In the field Path I write gnome-terminal. In the field Arguments I write -e 'R CMD INSTALL $(ProjectName)' (So it executes the R package installation command with the appropriate package name. For it to work the project name and the R source package must have the same name). Then I create (with Gimp) appropriate icons. Finally I check to Yes the Save all files and Capture output options. Now reamins to test it.

So I click in the newly created icon (the one that install the source package inside the working space directory with the same name as the project), and in the output window I get:

Current working directory: /home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace
Running program: "gnome-terminal" -e 'R CMD INSTALL codelitepkg'
Program exited with return code: 0

so, there is not a log of the installation process. In fact, it opens temporarily an ubuntu console and one can see the log of installation process (in progress), but it gets closed when the process ends. So if there is some error maybe may be difficult to have the time to see it.
TODO: How to solve this?
In this case the process goes right as I can see when I open a R console (from Codelite) and write:

> require("codelitepkg")
Loading required package: codelitepkg
Loading required package: Rcpp
> rcpp_hello_world()
[[1]]
[1] "foo" "bar"

[[2]]
[1] 0 1

Notice that one may eventually try to compile only the C++ from the standard way in Codelite. It will not work because the Rcpp.h is required. In fact, in the Build I get:

----------Build Started--------
"make"  -j 2 -f "codelite-workspace_wsp.mk"
----------Building project:[ codelitepkg - Debug ]----------
In file included from /home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.cpp:1:
/home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.h:4:18: error: Rcpp.h: No such file or directory
g++ -c  "/home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.cpp" -g  -o ./Debug/rcpp_hello_world.o "-I." "-I." 
In file included from /home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.cpp:1:
/home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.h:17: error: ‘RcppExport’ does not name a type
/home/juan/Desktop/facu/investigacion_ensayos/codelite-workspace/codelitepkg/src/rcpp_hello_world.cpp:3: error: ‘SEXP’ does not name a type
make[1]: *** [Debug/rcpp_hello_world.o] Error 1
make: *** [All] Error 2
----------Build Ended----------

I think that the following famous Rcpp arguments passed to g++ are required:

PKG_LIBS = `$(R_HOME)/bin/Rscript -e "Rcpp:::LdFlags()"`

that one can find inside the Makevars file inside the src/ in the R source package directory. Eventually it may be interesting to build a R source package that can be R installed (as a package) and which C++ code can be called from a main.cpp file in the codelite project in order to (for example) test the C++ code inside the R source package without calling to R. In other words, some kind of programming in parallel R and C++ in such a way that it can be build into an R package, but also, its C++ part can be run separately from a main.cpp

TODO: How to solve this problem?

Maybe I must enter into this. So, it seems that the process consists (in a first approximation) on four steps:

1) preprocessing
2) compilation
3) assembly
4) linking

If in a linux console I write:

$(R RHOME)/bin/Rscript -e "Rcpp:::LdFlags()"

I obtain:

-L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib

so, where I must put this inside the Codelite IDE?

So I do the following. First, one must notice that there are two things to do. One is to specify where the R and Rcpp headers are. Second specify appropriate linking parameters to Rcpp precompiled lib.

For the first task I search trough my system where R.h and Rcpp.h are, and then include those paths in Codelite. Where? Well you click right button on the project (named codelitepkg in this case) in the window that contains the "workspace tree". Then I choose Settings -> Compiler -> Additional Search Path, and it this field I write (the previously mentioned paths):

/usr/local/lib/R/site-library/Rcpp/include;/usr/share/R/include

so, the paths are separated by a semicolon. The first path is the path to R.h (and related headers), the second path is the path to Rcpp.h (and related headers).
Now, in respect to linking the code to the Rcpp precompiled library I do: (same as before) -> Settings -> Linker -> Options, and in that field I write:

`/usr/lib64/R/bin/Rscript -e "Rcpp:::LdFlags()"`

And it works, it compiles and run. Also as a test, inside the files rcpp_hello_world.cpp and rcpp_hello_world.h I define and declare a function that I cal from main.cpp and it works.

Now there remains some things to solve. The "parameters" that I pass to codelite are very system specific. More precisely, the paths that I set in the compiler settings are specified at hand. Is there some way to obtain this paths automatically? For example, if in a ubuntu console one can get:

$ R RHOME
/usr/lib64/R

so, if R is installed it can give some paths. Can it give the paths to include its headers?Can it give the paths to include the Rcpp headers? In answering that question it may be useful too:

$(R RHOME)/bin/Rscript -e "Rcpp:::CxxFlags()"
-I/usr/local/lib/R/site-library/Rcpp/include

TODO: Solve those questions.

In respect to this question, I submit a question to the codelite-user mailing list, and also make the same question on the codelite forum. Lets see what happen.

Also note here that it seems that the CodeLite uses a makefile based system to process the settings that can be specified.
So, Eran reply on the forum (thanks Eran ;)). He suggest this: Write the followingin the Linker options:

$(shell $(shell R RHOME)/bin/Rscript -e "Rcpp:::LdFlags()")

and it works. Now remains to do the analogous thing in the the include options.

So, in order to do that I do the following. First I delete what I had written before in (right click project name) -> Compiler -> Additional Search Path. Now the idea is to specify the samein ... Compiler -> Compiler Options via "-I". So there, in ... Compiler -> Compiler Options there is already "-g", so I live it there and append to the end the "new" compiler options. More precisely, in the ... -> Compiler Options I write:

-g $(shell $(shell R RHOME)/bin/Rscript -e "Rcpp:::CxxFlags()") -I$(shell $(shell R RHOME)/bin/Rscript -e "cat(R.home('include'))")

So, as it has 3 parts, the "-g" that is there before, and one to include the Rcpp headers:

$(shell $(shell R RHOME)/bin/Rscript -e "Rcpp:::CxxFlags()")

and one to include the R headers:

$(shell R RHOME)/bin/Rscript -e "cat(R.home('include'))")

Note that I made use of the following R commands:

> R.home('include')
[1] "/usr/share/R/include"
> require(Rcpp)
Loading required package: Rcpp
> Rcpp:::LdFlags()
-L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib

The "cat()" is to "clean" the output of "R.home('include')". And that is, with this thing, itworks (the code compiles and run).

Salut !

Learning Roxygen, Doxygen - n.1

2011-02-20T20:24:00.004-03:00

Fist, Doxygen:

Check this.

Dosygen + Emacs: this, this (doxymacs).

Doxygen + Eclipse: this.

Doxygen extensions: this.

Doxygen tutorials, intros: here.

Doxygen, getting started: here.

TODO

Second, Roxygen:

TODO

Salut !

Learning - Debugging in R or/and C++ - n.1

2011-02-20T17:24:00.000-03:00

So, I'm looking to improve my resources as a code writer. So I look for IDEs (previous post), also I have in mind Roxygen (see previous post, and maybe using Doxygen for the non R code) in order to practice an appropriate code documentation style.

But, what about debugging? This may enhance the code development a lot !!! In fact was this the thing that makes me think about debugging tools.

From the C++ side there exist gdb (look here, and here). And it seems that it can be integrated to Emacs (see here). Thoug it seems that debugging simultaneously R and C++ code (the last one integrated to R) is not an "easy" task in the sense that there is no direct way (see here, and here).

Keywords: debugging, gdb (related to g++)
Salut !

Pseudo-Random number generators in Boost C++ Library

2011-02-19T17:08:00.000-03:00

Here I pick some info about random number generation in Boost C++ Library. It is about using the Boost.Random C++ Library.

Here some examples of its usage: ex1, ex2 (there is also examples in the Boost.Random C++ Library).

And here a nice arXiv paper on random number in scientific research.

I think that Mersenne Twister (mt29937() in the boost) is a good candidate, becauseit is random enough and also fast.

Salut !

C++, STL, BGL Learning - Some examples - n.2

2011-02-19T11:33:00.009-03:00

In a previous post I try a simple example of a C++ program that uses STL. Now in this post I will try a simple program that uses BGL.

So, I try an example from here:

  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/dijkstra_shortest_paths.hpp>

  using namespace boost;

  int main(int,char*[])
  {
    // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] =
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);
    ...
    return 0;
  }

So, in a ubuntu console, I do:

$ g++ example-basic-bgl.cpp 
example-basic-bgl.cpp:4:42: error: boost/graph/graph_traits.hpp: No such file or directory
example-basic-bgl.cpp:5:44: error: boost/graph/adjacency_list.hpp: No such file or directory
example-basic-bgl.cpp:6:53: error: boost/graph/dijkstra_shortest_paths.hpp: No such file or directory
example-basic-bgl.cpp:8: error: ‘boost’ is not a namespace-name
example-basic-bgl.cpp:8: error: expected namespace-name before ‘;’ token
example-basic-bgl.cpp: In function ‘int main(int, char**)’:
example-basic-bgl.cpp:13: error: expected initializer before ‘<’ token
example-basic-bgl.cpp:28: error: ‘Graph’ was not declared in this scope
example-basic-bgl.cpp:28: error: expected ‘;’ before ‘g’
example-basic-bgl.cpp:32: error: ‘g’ was not declared in this scope
example-basic-bgl.cpp:32: error: ‘add_edge’ was not declared in this scope
example-basic-bgl.cpp:33: error: expected primary-expression before ‘...’ token
example-basic-bgl.cpp:33: error: expected ‘;’ before ‘...’ token

so, the BGL is not installed on my system. What about BGL on ubuntu? Maybe this post may help. So I do:

$ sudo apt-get install libboost-graph-dev
[sudo] password for juan: 
Reading package lists... Done
Building dependency tree       
Reading state information... Done
The following packages were automatically installed and are no longer required:
  libaccess-bridge-java libboost-python1.38.0 icedtea-6-jre-cacao openjdk-6-jre-lib openjdk-6-jre-headless libaccess-bridge-java-jni dkms tzdata-java gccxml rhino
  ca-certificates-java libjline-java
Use 'apt-get autoremove' to remove them.
The following extra packages will be installed:
  gccxml libboost-date-time1.38-dev libboost-date-time1.38.0 libboost-filesystem1.38-dev libboost-filesystem1.38.0 libboost-graph1.38-dev libboost-graph1.38.0
  libboost-iostreams1.38-dev libboost-iostreams1.38.0 libboost-math1.38-dev libboost-math1.38.0 libboost-program-options1.38-dev libboost-program-options1.38.0
  libboost-python1.38.0 libboost-regex1.38-dev libboost-regex1.38.0 libboost-serialization1.38-dev libboost-serialization1.38.0 libboost-signals1.38-dev
  libboost-signals1.38.0 libboost-system1.38-dev libboost-system1.38.0 libboost-test1.38-dev libboost-test1.38.0 libboost-thread1.38-dev libboost-thread1.38.0
  libboost-wave1.38-dev libboost-wave1.38.0 libboost1.38-dev libboost1.38-doc libicu-dev
Suggested packages:
  graphviz icu-doc
Recommended packages:
  libboost-python1.38-dev
The following NEW packages will be installed:
  gccxml libboost-date-time1.38-dev libboost-date-time1.38.0 libboost-filesystem1.38-dev libboost-filesystem1.38.0 libboost-graph-dev libboost-graph1.38-dev
  libboost-graph1.38.0 libboost-iostreams1.38-dev libboost-iostreams1.38.0 libboost-math1.38-dev libboost-math1.38.0 libboost-program-options1.38-dev
  libboost-program-options1.38.0 libboost-python1.38.0 libboost-regex1.38-dev libboost-regex1.38.0 libboost-serialization1.38-dev libboost-serialization1.38.0
  libboost-signals1.38-dev libboost-signals1.38.0 libboost-system1.38-dev libboost-system1.38.0 libboost-test1.38-dev libboost-test1.38.0 libboost-thread1.38-dev
  libboost-thread1.38.0 libboost-wave1.38-dev libboost-wave1.38.0 libboost1.38-dev libboost1.38-doc libicu-dev
0 upgraded, 32 newly installed, 0 to remove and 15 not upgraded.
Need to get 59.0MB of archives.
After this operation, 314MB of additional disk space will be used.
Do you want to continue [Y/n]? Y
Get:1 http://ar.archive.ubuntu.com karmic/main gccxml 0.9.0+cvs20080525-1ubuntu1 [4,013kB]
Get:2 http://ar.archive.ubuntu.com karmic/main libboost1.38-dev 1.38.0-6ubuntu6 [3,786kB]                                                                              
Get:3 http://ar.archive.ubuntu.com karmic/main libboost-date-time1.38.0 1.38.0-6ubuntu6 [40.1kB]                                                                       
Get:4 http://ar.archive.ubuntu.com karmic/main libboost-serialization1.38.0 1.38.0-6ubuntu6 [232kB]                                                                    
Get:5 http://ar.archive.ubuntu.com karmic/main libboost-serialization1.38-dev 1.38.0-6ubuntu6 [375kB]                                                                  
Get:6 http://ar.archive.ubuntu.com karmic/main libboost-date-time1.38-dev 1.38.0-6ubuntu6 [166kB]                                                                      
Get:7 http://ar.archive.ubuntu.com karmic/main libboost-system1.38.0 1.38.0-6ubuntu6 [24.9kB]                                                                          
Get:8 http://ar.archive.ubuntu.com karmic/main libboost-filesystem1.38.0 1.38.0-6ubuntu6 [46.2kB]                                                                      
Get:9 http://ar.archive.ubuntu.com karmic/main libboost-system1.38-dev 1.38.0-6ubuntu6 [32.6kB]                                                                        
Get:10 http://ar.archive.ubuntu.com karmic/main libboost-filesystem1.38-dev 1.38.0-6ubuntu6 [76.5kB]                                                                   
Get:11 http://ar.archive.ubuntu.com karmic/main libboost-test1.38.0 1.38.0-6ubuntu6 [183kB]                                                                            
Get:12 http://ar.archive.ubuntu.com karmic/main libboost-test1.38-dev 1.38.0-6ubuntu6 [383kB]                                                                          
Get:13 http://ar.archive.ubuntu.com karmic/main libboost-graph1.38-dev 1.38.0-6ubuntu6 [415kB]                                                                         
Get:14 http://ar.archive.ubuntu.com karmic/universe libboost-graph-dev 1.38.1 [1,702B]                                                                                 
Get:15 http://ar.archive.ubuntu.com karmic/main libboost-graph1.38.0 1.38.0-6ubuntu6 [124kB]                                                                           
Get:16 http://ar.archive.ubuntu.com karmic/main libboost-regex1.38.0 1.38.0-6ubuntu6 [341kB]                                                                           
Get:17 http://ar.archive.ubuntu.com karmic/main libicu-dev 4.0.1-2ubuntu2 [8,225kB]                                                                                    
Get:18 http://ar.archive.ubuntu.com karmic/main libboost-regex1.38-dev 1.38.0-6ubuntu6 [592kB]                                                                         
Get:19 http://ar.archive.ubuntu.com karmic/main libboost-iostreams1.38.0 1.38.0-6ubuntu6 [34.8kB]                                                                      
Get:20 http://ar.archive.ubuntu.com karmic/main libboost-iostreams1.38-dev 1.38.0-6ubuntu6 [132kB]                                                                     
Get:21 http://ar.archive.ubuntu.com karmic/main libboost-math1.38.0 1.38.0-6ubuntu6 [449kB]                                                                            
Get:22 http://ar.archive.ubuntu.com karmic/main libboost-math1.38-dev 1.38.0-6ubuntu6 [2,052kB]                                                                        
Get:23 http://ar.archive.ubuntu.com karmic/main libboost-program-options1.38.0 1.38.0-6ubuntu6 [119kB]                                                                 
Get:24 http://ar.archive.ubuntu.com karmic/main libboost-program-options1.38-dev 1.38.0-6ubuntu6 [194kB]                                                               
Get:25 http://ar.archive.ubuntu.com karmic/main libboost-python1.38.0 1.38.0-6ubuntu6 [245kB]                                                                          
Get:26 http://ar.archive.ubuntu.com karmic/main libboost-signals1.38.0 1.38.0-6ubuntu6 [47.7kB]                                                                        
Get:27 http://ar.archive.ubuntu.com karmic/main libboost-signals1.38-dev 1.38.0-6ubuntu6 [68.0kB]                                                                      
Get:28 http://ar.archive.ubuntu.com karmic/main libboost-thread1.38.0 1.38.0-6ubuntu6 [47.6kB]                                                                         
Get:29 http://ar.archive.ubuntu.com karmic/main libboost-thread1.38-dev 1.38.0-6ubuntu6 [80.7kB]                                                                       
Get:30 http://ar.archive.ubuntu.com karmic/main libboost-wave1.38.0 1.38.0-6ubuntu6 [249kB]                                                                            
Get:31 http://ar.archive.ubuntu.com karmic/main libboost-wave1.38-dev 1.38.0-6ubuntu6 [551kB]                                                                          
Get:32 http://ar.archive.ubuntu.com karmic/main libboost1.38-doc 1.38.0-6ubuntu6 [35.7MB]                                                                              
Fetched 59.0MB in 2min 32s (388kB/s)                                                                                                                                   
Extracting templates from packages: 100%
Selecting previously deselected package gccxml.
(Reading database ... 226092 files and directories currently installed.)
Unpacking gccxml (from .../gccxml_0.9.0+cvs20080525-1ubuntu1_amd64.deb) ...
Selecting previously deselected package libboost1.38-dev.
Unpacking libboost1.38-dev (from .../libboost1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-date-time1.38.0.
Unpacking libboost-date-time1.38.0 (from .../libboost-date-time1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-serialization1.38.0.
Unpacking libboost-serialization1.38.0 (from .../libboost-serialization1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-serialization1.38-dev.
Unpacking libboost-serialization1.38-dev (from .../libboost-serialization1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-date-time1.38-dev.
Unpacking libboost-date-time1.38-dev (from .../libboost-date-time1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-system1.38.0.
Unpacking libboost-system1.38.0 (from .../libboost-system1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-filesystem1.38.0.
Unpacking libboost-filesystem1.38.0 (from .../libboost-filesystem1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-system1.38-dev.
Unpacking libboost-system1.38-dev (from .../libboost-system1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-filesystem1.38-dev.
Unpacking libboost-filesystem1.38-dev (from .../libboost-filesystem1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-test1.38.0.
Unpacking libboost-test1.38.0 (from .../libboost-test1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-test1.38-dev.
Unpacking libboost-test1.38-dev (from .../libboost-test1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-graph1.38-dev.
Unpacking libboost-graph1.38-dev (from .../libboost-graph1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-graph-dev.
Unpacking libboost-graph-dev (from .../libboost-graph-dev_1.38.1_amd64.deb) ...
Selecting previously deselected package libboost-graph1.38.0.
Unpacking libboost-graph1.38.0 (from .../libboost-graph1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-regex1.38.0.
Unpacking libboost-regex1.38.0 (from .../libboost-regex1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libicu-dev.
Unpacking libicu-dev (from .../libicu-dev_4.0.1-2ubuntu2_amd64.deb) ...
Selecting previously deselected package libboost-regex1.38-dev.
Unpacking libboost-regex1.38-dev (from .../libboost-regex1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-iostreams1.38.0.
Unpacking libboost-iostreams1.38.0 (from .../libboost-iostreams1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-iostreams1.38-dev.
Unpacking libboost-iostreams1.38-dev (from .../libboost-iostreams1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-math1.38.0.
Unpacking libboost-math1.38.0 (from .../libboost-math1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-math1.38-dev.
Unpacking libboost-math1.38-dev (from .../libboost-math1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-program-options1.38.0.
Unpacking libboost-program-options1.38.0 (from .../libboost-program-options1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-program-options1.38-dev.
Unpacking libboost-program-options1.38-dev (from .../libboost-program-options1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-python1.38.0.
Unpacking libboost-python1.38.0 (from .../libboost-python1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-signals1.38.0.
Unpacking libboost-signals1.38.0 (from .../libboost-signals1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-signals1.38-dev.
Unpacking libboost-signals1.38-dev (from .../libboost-signals1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-thread1.38.0.
Unpacking libboost-thread1.38.0 (from .../libboost-thread1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-thread1.38-dev.
Unpacking libboost-thread1.38-dev (from .../libboost-thread1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-wave1.38.0.
Unpacking libboost-wave1.38.0 (from .../libboost-wave1.38.0_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost-wave1.38-dev.
Unpacking libboost-wave1.38-dev (from .../libboost-wave1.38-dev_1.38.0-6ubuntu6_amd64.deb) ...
Selecting previously deselected package libboost1.38-doc.
Unpacking libboost1.38-doc (from .../libboost1.38-doc_1.38.0-6ubuntu6_all.deb) ...
Processing triggers for man-db ...
Processing triggers for doc-base ...
Processing 1 added doc-base file(s)...
Registering documents with scrollkeeper...
Setting up gccxml (0.9.0+cvs20080525-1ubuntu1) ...
Setting up libboost1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-date-time1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-serialization1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-serialization1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-date-time1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-system1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-filesystem1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-system1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-filesystem1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-test1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-test1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-graph1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-graph-dev (1.38.1) ...
Setting up libboost-graph1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-regex1.38.0 (1.38.0-6ubuntu6) ...

Setting up libicu-dev (4.0.1-2ubuntu2) ...
Setting up libboost-regex1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-iostreams1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-iostreams1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-math1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-math1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-program-options1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-program-options1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-python1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-signals1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-signals1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-thread1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-thread1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost-wave1.38.0 (1.38.0-6ubuntu6) ...

Setting up libboost-wave1.38-dev (1.38.0-6ubuntu6) ...
Setting up libboost1.38-doc (1.38.0-6ubuntu6) ...
Processing triggers for libc-bin ...
ldconfig deferred processing now taking place

So, it seems that the BGL for ubuntu is installed in my system now. It took 341MB !!!. Now I get:

$ ls /usr/include/boost/graph/
adjacency_iterator.hpp           depth_first_search.hpp       graphviz.hpp                    minimum_degree_ordering.hpp     simple_point.hpp
adjacency_list.hpp               detail                       gursoy_atun_layout.hpp          named_function_params.hpp       sloan_ordering.hpp
adjacency_list_io.hpp            dijkstra_shortest_paths.hpp  howard_cycle_ratio.hpp          named_graph.hpp                 smallest_last_ordering.hpp
adjacency_matrix.hpp             dominator_tree.hpp           incremental_components.hpp      neighbor_bfs.hpp                small_world_generator.hpp
adj_list_serialize.hpp           edge_connectivity.hpp        is_kuratowski_subgraph.hpp      page_rank.hpp                   stanford_graph.hpp
astar_search.hpp                 edge_list.hpp                isomorphism.hpp                 planar_canonical_ordering.hpp   strong_components.hpp
bandwidth.hpp                    edmonds_karp_max_flow.hpp    is_straight_line_drawing.hpp    planar_detail                   subgraph.hpp
bc_clustering.hpp                edmunds_karp_max_flow.hpp    iteration_macros.hpp            planar_face_traversal.hpp       topological_sort.hpp
bellman_ford_shortest_paths.hpp  erdos_renyi_generator.hpp    iteration_macros_undef.hpp      plod_generator.hpp              transitive_closure.hpp
betweenness_centrality.hpp       exception.hpp                johnson_all_pairs_shortest.hpp  prim_minimum_spanning_tree.hpp  transpose_graph.hpp
biconnected_components.hpp       filtered_graph.hpp           kamada_kawai_spring_layout.hpp  profile.hpp                     tree_traits.hpp
boyer_myrvold_planar_test.hpp    floyd_warshall_shortest.hpp  king_ordering.hpp               properties.hpp                  two_bit_color_map.hpp
breadth_first_search.hpp         fruchterman_reingold.hpp     kolmogorov_max_flow.hpp         property_iter_range.hpp         undirected_dfs.hpp
chrobak_payne_drawing.hpp        graph_archetypes.hpp         kruskal_min_spanning_tree.hpp   push_relabel_max_flow.hpp       vector_as_graph.hpp
circle_layout.hpp                graph_as_tree.hpp            leda_graph.hpp                  random.hpp                      visitors.hpp
compressed_sparse_row_graph.hpp  graph_concepts.hpp           make_biconnected_planar.hpp     random_layout.hpp               wavefront.hpp
connected_components.hpp         graphml.hpp                  make_connected.hpp              r_c_shortest_paths.hpp          write_dimacs.hpp
copy.hpp                         graph_selectors.hpp          make_maximal_planar.hpp         read_dimacs.hpp
create_condensation_graph.hpp    graph_test.hpp               matrix_as_graph.hpp             relax.hpp
cuthill_mckee_ordering.hpp       graph_traits.hpp             max_cardinality_matching.hpp    reverse_graph.hpp
dag_shortest_paths.hpp           graph_utility.hpp            metric_tsp_approx.hpp           sequential_vertex_coloring.hpp

so BGL seems to be there. Lets look if the program compiles. So I do:

$ g++ example-basic-bgl.cpp 
In file included from /usr/include/c++/4.4/backward/hash_set:59,
                 from /usr/include/boost/graph/adjacency_list.hpp:25,
                 from example-basic-bgl.cpp:5:
/usr/include/c++/4.4/backward/backward_warning.h:28:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated.
example-basic-bgl.cpp: In function ‘int main(int, char**)’:
example-basic-bgl.cpp:33: error: expected primary-expression before ‘...’ token
example-basic-bgl.cpp:33: error: expected ‘;’ before ‘...’ token

so, there is a warning saying that backward_warning.h include at least one antiquated or deprecated (in spanish: obsoleto). Also there are compilation errors.
I forgot to remove ... in the example. So I remove it and try again:

$ g++ example-basic-bgl.cpp 
In file included from /usr/include/c++/4.4/backward/hash_set:59,
                 from /usr/include/boost/graph/adjacency_list.hpp:25,
                 from example-basic-bgl.cpp:5:
/usr/include/c++/4.4/backward/backward_warning.h:28:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated.
$ ./a.out

So, it compile and run. But it shows nothing on the screen because the program example is not intended for this. Lets enhance the program a little and see what happens. So I make a new version of the program (I still pick the idea from here):

  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/dijkstra_shortest_paths.hpp>

  using namespace boost;
  
  int main(int,char*[])
  {
    // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] = 
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);

    // get the property map for vertex indices
    typedef property_map<Graph, vertex_index_t>::type IndexMap;
    IndexMap index = get(vertex_index, g);

    // accessing the vertex set
    std::cout << "vertices(g) = ";
    typedef graph_traits<Graph>::vertex_iterator vertex_iter;
    std::pair<vertex_iter, vertex_iter> vp;
    for (vp = vertices(g); vp.first != vp.second; ++vp.first)
      std::cout << index[*vp.first] <<  " ";
    std::cout << std::endl;

    // accessing the edge set
    std::cout << "edges(g) = ";
    graph_traits<Graph>::edge_iterator ei, ei_end;
    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        std::cout << "(" << index[source(*ei, g)] 
                  << "," << index[target(*ei, g)] << ") ";
    std::cout << std::endl;

    return 0;
  }

compile and run it:

$ g++ example-basic-bgl-v1.cpp 
In file included from /usr/include/c++/4.4/backward/hash_set:59,
                 from /usr/include/boost/graph/adjacency_list.hpp:25,
                 from example-basic-bgl-v1.cpp:5:
/usr/include/c++/4.4/backward/backward_warning.h:28:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated.
$ ./a.out 
vertices(g) = 0 1 2 3 4 
edges(g) = (0,1) (0,3) (2,0) (3,2) (2,4) (1,3) (3,4)

so it works !!!. Now there is another bit of example code that can be added to this program that is explained in here (the same source of the above code). It uses something called functor (name inherited from type theory; here an idea of what a functor is). Lets try it. So I make a new program version:

  #include <iostream>                  // for std::cout
  #include <utility>                   // for std::pair
  #include <algorithm>                 // for std::for_each
  #include <boost/graph/graph_traits.hpp>
  #include <boost/graph/adjacency_list.hpp>
  #include <boost/graph/dijkstra_shortest_paths.hpp>

  using namespace boost;

  template <class Graph> struct exercise_vertex {
    // the functor
    exercise_vertex(Graph& g_) : g(g_) {}

    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;

    // vertex descriptor
    void operator()(const Vertex& v) const
    {
      typedef graph_traits<Graph> GraphTraits;
      typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);

      // which vertex
      std::cout << "adjacent structure of vertex: " << index[v] << std::endl;

      // out edges
      std::cout << "out-edges: ";
      typename GraphTraits::out_edge_iterator out_i, out_end;
      typename GraphTraits::edge_descriptor e;
      for (tie(out_i, out_end) = out_edges(v, g); 
           out_i != out_end; ++out_i) {
        e = *out_i;
        Vertex src = source(e, g), targ = target(e, g);
        std::cout << "(" << index[src] << "," 
                  << index[targ] << ") ";
      }
      std::cout << std::endl;

      // in edges
      std::cout << "in-edges: ";
      typename GraphTraits::in_edge_iterator in_i, in_end;
      for (tie(in_i, in_end) = in_edges(v,g); 
           in_i != in_end; ++in_i) {
        e = *in_i;
        Vertex src = source(e, g), targ = target(e, g);
        std::cout << "(" << index[src] << "," << index[targ] << ") ";
      }
      std::cout << std::endl;

      // adjacent vertices (notice that it only returns the vertex that are targets of out edges of vertex v)
      std::cout << "adjacent vertices: ";
      typename GraphTraits::adjacency_iterator ai;
      typename GraphTraits::adjacency_iterator ai_end;
      for (tie(ai, ai_end) = adjacent_vertices(v, g); ai != ai_end; ++ai)
        std::cout << index[*ai] <<  " ";
      std::cout << std::endl;

      // ...

    }

    Graph& g;
  };
  
  int main(int,char*[])
  {
    // create a typedef for the Graph type
    typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

    // Make convenient labels for the vertices
    enum { A, B, C, D, E, N };
    const int num_vertices = N;
    const char* name = "ABCDE";

    // writing out the edges in the graph
    typedef std::pair<int, int> Edge;
    Edge edge_array[] = 
    { Edge(A,B), Edge(A,D), Edge(C,A), Edge(D,C),
      Edge(C,E), Edge(B,D), Edge(D,E) };
    const int num_edges = sizeof(edge_array)/sizeof(edge_array[0]);

    // declare a graph object
    Graph g(num_vertices);

    // add the edges to the graph object
    for (int i = 0; i < num_edges; ++i)
      add_edge(edge_array[i].first, edge_array[i].second, g);

    // get the property map for vertex indices
    typedef property_map<Graph, vertex_index_t>::type IndexMap;
    IndexMap index = get(vertex_index, g);

    // accessing the vertex set
    std::cout << "vertices(g) = ";
    typedef graph_traits<Graph>::vertex_iterator vertex_iter;
    std::pair<vertex_iter, vertex_iter> vp;
    for (vp = vertices(g); vp.first != vp.second; ++vp.first)
      std::cout << index[*vp.first] <<  " ";
    std::cout << std::endl;

    // accessing the edge set
    std::cout << "edges(g) = ";
    graph_traits<Graph>::edge_iterator ei, ei_end;
    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
        std::cout << "(" << index[source(*ei, g)] 
                  << "," << index[target(*ei, g)] << ") ";
    std::cout << std::endl;

    // the adjacency structure
    std::for_each(vertices(g).first, vertices(g).second,
                  exercise_vertex<Graph>(g));

    return 0;
  }

compile and run it:

$ g++ example-basic-bgl-v2.cpp 
In file included from /usr/include/c++/4.4/backward/hash_set:59,
                 from /usr/include/boost/graph/adjacency_list.hpp:25,
                 from example-basic-bgl-v2.cpp:5:
/usr/include/c++/4.4/backward/backward_warning.h:28:2: warning: #warning This file includes at least one deprecated or antiquated header which may be removed without further notice at a future date. Please use a non-deprecated interface with equivalent functionality instead. For a listing of replacement headers and interfaces, consult the file backward_warning.h. To disable this warning use -Wno-deprecated.
$ ./a.out 
vertices(g) = 0 1 2 3 4 
edges(g) = (0,1) (0,3) (2,0) (3,2) (2,4) (1,3) (3,4) 
adjacent structure of vertex: 0
out-edges: (0,1) (0,3) 
in-edges: (2,0) 
adjacent vertices: 1 3 
adjacent structure of vertex: 1
out-edges: (1,3) 
in-edges: (0,1) 
adjacent vertices: 3 
adjacent structure of vertex: 2
out-edges: (2,0) (2,4) 
in-edges: (3,2) 
adjacent vertices: 0 4 
adjacent structure of vertex: 3
out-edges: (3,2) (3,4) 
in-edges: (0,3) (1,3) 
adjacent vertices: 2 4 
adjacent structure of vertex: 4
out-edges: 
in-edges: (2,4) (3,4) 
adjacent vertices:

so it works !!! Notice that the adjacent vertex returned by adjacent_vertices(v, g) are target vertex of the outgoing edges adjacent to v (the target vertex of the ingoing edges does not appears in this list).

So, now remains to understand more clearly what the code does. For example:
TODO: What is adjacence_list< > here?
TODO: What is property_map< >; here?
The other thing more or less I imagine what they do.

Salut !

C++, STL, BGL Learning - Some examples - n.1

2011-02-19T08:22:00.009-03:00

The idea in this series of postings is to try some code in order to learn C++, STL and BGL.

So, in this first post I will start with an example of STL. So, from here I pick this example:

#include <string.h>
#include <algo.h>
#include <vector.h>
#include <stdlib.h>
#include <iostream.h>
 
main ()
{
  vector<int> v;  // create an empty vector of integers
  int input;
  while (cin >> input)    // while not end of file
    v.push_back (input);  // append to vector
 
  // sort takes two random iterators, and sorts the elements between 
  // them.  As is always the case in STL, this includes the value
  // referred to by first but not the one referred to by last; indeed,
  // this is often the past-the-end value, and is therefore not
  // dereferenceable.
  sort(v.begin(), v.end());
 
  int n = v.size();
  for (int i = 0; i < n; i++)
    cout << v[i] << "\n";
}

I try to compile it and get:

$ g++ example_sort_vector.cpp 
example_sort_vector.cpp:2:18: error: algo.h: No such file or directory
example_sort_vector.cpp:3:20: error: vector.h: No such file or directory
example_sort_vector.cpp:5:22: error: iostream.h: No such file or directory
example_sort_vector.cpp: In function ‘int main()’:
example_sort_vector.cpp:9: error: ‘vector’ was not declared in this scope
example_sort_vector.cpp:9: error: expected primary-expression before ‘int’
example_sort_vector.cpp:9: error: expected ‘;’ before ‘int’
example_sort_vector.cpp:11: error: ‘cin’ was not declared in this scope
example_sort_vector.cpp:12: error: ‘v’ was not declared in this scope
example_sort_vector.cpp:19: error: ‘v’ was not declared in this scope
example_sort_vector.cpp:19: error: ‘sort’ was not declared in this scope
example_sort_vector.cpp:23: error: ‘cout’ was not declared in this scope

So, is STL installed by default on ubuntu? This ubuntu post may help. So, I try this:


$ sudo apt-get install build-essential
[sudo] password for juan: 
Reading package lists... Done
Building dependency tree       
Reading state information... Done
build-essential is already the newest version.
build-essential set to manually installed.
The following packages were automatically installed and are no longer required:
  libaccess-bridge-java icedtea-6-jre-cacao openjdk-6-jre-lib openjdk-6-jre-headless libaccess-bridge-java-jni dkms tzdata-java rhino ca-certificates-java
  libjline-java
Use 'apt-get autoremove' to remove them.
0 upgraded, 0 newly installed, 0 to remove and 15 not upgraded.

so, if essentials includes STL then it is already installed. But, I looked inside:

$ ls /usr/include/
aio.h        compiz       envz.h         gconv.h         langinfo.h  monetary.h     nfs                 pthread.h    semaphore.h  syslog.h      utmp.h
aliases.h    complex.h    err.h          getopt.h        lastlog.h   mqueue.h       nl_types.h          pty.h        setjmp.h     tar.h         utmpx.h
alloca.h     cpio.h       errno.h        GL              libgen.h    mtd            nss.h               pwd.h        sgtty.h      termcap.h     uuid
a.out.h      crypt.h      error.h        glob.h          libintl.h   nc_tparm.h     numpy               python2.5    shadow.h     term_entry.h  values.h
argp.h       ctype.h      eti.h          gnu             libio.h     ncurses_dll.h  obstack.h           python2.5_d  signal.h     term.h        video
argz.h       cursesapp.h  etip.h         gnu-versions.h  libpng      ncurses.h      panel.h             python2.6    sound        termio.h      wait.h
ar.h         cursesf.h    execinfo.h     grace_np.h      libpng12    net            paths.h             python2.6_d  spawn.h      termios.h     wchar.h
arpa         curses.h     fcntl.h        grp.h           libxml2     netash         pcrecpparg.h        rdma         stab.h       tgmath.h      wctype.h
asm          cursesm.h    features.h     gshadow.h       limits.h    netatalk       pcrecpp.h           readline     stdint.h     thread_db.h   wordexp.h
asm-generic  cursesp.h    fenv.h         iconv.h         link.h      netax25        pcre.h              re_comp.h    stdio_ext.h  tic.h         X11
assert.h     cursesw.h    fmtmsg.h       ieee754.h       linux       netdb.h        pcreposix.h         regex.h      stdio.h      time.h        xcb
bits         cursslk.h    fnmatch.h      ifaddrs.h       locale.h    neteconet      pcre_scanner.h      regexp.h     stdlib.h     ttyent.h      xen
blkid        dbus-1.0     form.h         inttypes.h      malloc.h    netinet        pcre_stringpiece.h  resolv.h     string.h     ucontext.h    xlocale.h
byteswap.h   dirent.h     fpu_control.h  jconfig.h       math.h      netipx         pngconf.h           rpc          strings.h    ulimit.h      zconf.h
bzlib.h      dlfcn.h      fstab.h        jerror.h        mcheck.h    netiucv        png.h               rpcsvc       stropts.h    unctrl.h      zlibdefs.h
c++          drm          fts.h          jmorecfg.h      memory.h    netpacket      poll.h              sched.h      sys          unistd.h      zlib.h
cblas_f77.h  elf.h        ftw.h          jpegint.h       menu.h      netrom         printf.h            scsi         syscall.h    ustat.h
cblas.h      endian.h     _G_config.h    jpeglib.h       mntent.h    netrose        protocols           search.h     sysexits.h   utime.h

so, there is no stl/ directory there. But, inside:

$ ls /usr/include/c++/4.4/
algorithm        cerrno     complex             cstdint          cxxabi.h             fstream           limits   parallel     stdexcept     typeinfo
array            cfenv      complex.h           cstdio           debug                functional        list     queue        streambuf     type_traits
backward         cfloat     condition_variable  cstdlib          deque                initializer_list  locale   random       string        unordered_map
bits             chrono     csetjmp             cstring          exception            iomanip           map      ratio        system_error  unordered_set
bitset           cinttypes  csignal             ctgmath          exception_defines.h  ios               memory   regex        tgmath.h      utility
c++0x_warning.h  ciso646    cstdarg             ctime            exception_ptr.h      iosfwd            mutex    set          thread        valarray
cassert          climits    cstdatomic          cwchar           ext                  iostream          new      sstream      tr1           vector
ccomplex         clocale    cstdbool            cwctype          fenv.h               istream           numeric  stack        tr1_impl      x86_64-linux-gnu
cctype           cmath      cstddef             cxxabi-forced.h  forward_list         iterator          ostream  stdatomic.h  tuple

so there appears names as iterator, vector, etc. So it seems that some (ubuntu) version of STL is there. So, I run the following example from the ubuntu post above:

#include <vector>
#include <iterator>
#include <iostream>

int main()
{
   std::vector<int> vec;   // declare a vector of int

   vec.push_back(10);      // add some values
   vec.push_back(20);
   vec.push_back(30);

   std::copy(vec.begin(), vec.end(), std::ostream_iterator<int>(std::cout, " "));
   std::cout << std::endl;
}

and it works:

$ g++ simple.cpp 
$ ./a.out 
10 20 30

So I modify the first example into the form:

#include <string.h>
#include <algorithm>
#include <vector>
#include <stdlib.h>
#include <iostream>

main ()
{

  using namespace std ;

  vector<int> v;  // create an empty vector of integers
  int input;
  while (cin >> input)    // while not end of file
    v.push_back (input);  // append to vector

  // sort takes two random iterators, and sorts the elements between 
  // them.  As is always the case in STL, this includes the value
  // referred to by first but not the one referred to by last; indeed,
  // this is often the past-the-end value, and is therefore not
  // dereferenceable.
  sort(v.begin(), v.end());

  int n = v.size();
  for (int i = 0; i < n; i++)
    cout << v[i] << "\n";
}

and it works:

$ g++ example_sort_vector.cpp 
$ ./a.out 
1
2
3
4
5
^X
1
2
3
4
5

Notice that algo.h is replaced by algorithm, vector.h by vector and iostream.h by iostream.

So, this first post of the series has to do with simply the compilation of a simple C++ program that uses STL.

So, this is a "crap", ubuntu has his own version of STL, that will bring me problems for sure. Is there a really standard STL?. The SGI STL is a particular STL version of STL? Here a list of ubuntu post related to this: post-1, post-2, post-3.

TODO: So, what is the best choice? I try to use the SGI or the ubuntu version?
TODO: BGL integrates with the ubuntu STL? And with the CGI?

Salut !

R Learning - S3 and S4 classes

2011-02-17T10:09:00.002-03:00

In this post I want to list material useful to deal with S3 and S4 classes.

Resources for S4 classes and methods

Salut !

R Learning - Rcpp, BGL - n.1

2011-02-16T23:01:00.018-03:00

In a previous post I see some difficulties in trying to build a self-sufficient package that integrates LGL via Rcpp. Maybe the alternative of using BGL is better in some way. After all, it is a "standard" library in C++, although it may be harder to learn (I think that it requires to learn pattern programming via templates). So, as I state before BGL yet has a corresponding R package named RBGL so this may be useful in some way. Even, maybe there yet exists ways to transform graph between the igraph and RBGL R packages.

TODO: Look if there are ways to transform graph between the igraph and RBGL R packages. Answ: There is, look downside in this post.

So, lets take a look at BGL. Here there is a presentation that shows some important aspects of BGL.

Clearly I will also need to learn (more) C++, so here there is a C++ tutorial.

Also I (probably) will need to learn STL (C++ standard template library), so i) here a basic STL tutorial; and ii) here are other one; iii) here another; iv) here an introduction. v) The STL main page here.

Also, here is some important discussion about templates and typedef.

TODO: I have started from iii), complete the reading of it. I also have started to read v), also complete the reading of it.

Here a list of source information about BGL: i) here a shot introduction.

Today (17-02-2011) I fond this in Lemon mailing list:

On Monday 14 February 2011 12:32:09 Alp?r J?ttner wrote:

> > I want to create a graph with weighted edges and iterate through
> > outgoing edges of a given node with ascending weights.
>
> Unfortunately you must somehow sort the edges by hand in this case.

Dear all,

It occurred to me earlier that using STL algorithms with LEMON would be pretty
nice indeed. This would solve the above issues as well. Some of the most used
STL algorithms (like "find", "copy", etc.) are reimplemented in LEMON over
LEMON maps ("mapCopy", "mapFind", etc.), but the lack of a good "sort",
"count", "replace", etc. is a real pain. You constantly need to copy out maps
into a std::vectors or similar, call the STL algorithm and then plug the
result back to LEMON somehow.

I once started to write an iterator adaptor class that would make a LEMON
nodemap or arcmap look to STL like a standard STL iterator. This would make it
possible to seamlessly call STL algorithms, like "sort", directly to LEMON
maps without the need to copy the maps out into STL containers. I achieved
some sort of advance, but my lack of time and C++ skills inhibited me to
decide whether the fact that it does not work is due to that I coded the idea
badly, or it is straight out impossible to do what I want.

I attach the code I could come up with to this mail in the hope that someone
more knowledgeable than me would find it useful, or finish it up, or at least
explain me why the idea I tried to implement does not work. In fact, I only
did the ForwardIterator, so "sort" is not expected to work but "find" and
"copy" are. Doing the RandomAccessIterator is another matter, of course.

The idea is to have an iterator adaptor class that, given a graph 'g', a
nodemap 'm(g)' and a node iterator 'n(g)', would make it possible to declare

node_map_it it(m, n);

and then 'it' would return the node the cursor is at, and '*it' would give the
map's value associated with this node. The same for arcs.

What I have so far is:

1. STL copy into output iterator works

 copy (arc_map_it<int>(w, ArcIt(g)),
       arc_map_it<int>(w, INVALID),
       ostream_iterator<int>(cout, "\n"));

2. STL copy into std::list does not seem to work (compiles but does not print
anything at all)

 list<int> l;
 copy(arc_map_it<int>(w, ArcIt(g)),
      arc_map_it<int>(w, INVALID),
      l.begin());

 copy (l.begin(), l.end(), ostream_iterator<int>(cout, "\n"));

3. STL find halfway works: finds the value but does not return the
corresponding node

 arc_map_it<int> it = find(arc_map_it<int>(w, ArcIt(g)),
                           arc_map_it<int>(w, INVALID),
                           42);
 // this writes 42 as expected
 cout << "Map value found: " << *it << endl;

 // cannot get this to compile
 //  cout << "Node id with weight 42: " << g.id(it) << endl;

I am open to comments, should you have any idea how to improve it further. I
really would like to see something similar in LEMON.

Best regards,
Gabor

So, it seems that BGL is better after all, it is more standard so seems that it also has more standard functionalities. In this case, it seems that using BGL is "easy" to sort a weighted adjacent list, but if you want to do that thing using LGL you has two ways, one implement yout own sort algorithm, second "copy" some things to STL format sort and "copy back" to LGL.

Here there are a RBGL overview (on CRAN) that may be useful.

It seems that RBGL is not a package that entirely provides tools to deal with graphs. It seems that RBGL complements the graph package which (seems that its) main graph object is named graphNEL. So, it seems that the idea is that some "standar" functions (as for example the Dijkstra algorithm) is provided from RBGL to the graph packages.It seems that the graph package is slower thant the igraph package, so maybe it is useful to transform a graphNEL object to a igraph object (and visceversa), here are something about that. In general, a good introduction to the graph package is in its vignette (Notice that there are other graph class objects in addition of graphNEL).

Salut !

R Learning - Building a self-sufficient package that integrates the C++ LGL via Rcpp - n.2 : Trying something

2011-02-15T17:04:00.014-03:00

In a previous post I was looking for a way of building a R package that integrates LGL (Lemon Graph Library) in a self-sufficient way. In other words, build a R package that contains C++ code that uses the LGL but does not need that LGL was previously installed.

So, I will try the following. I pick a working directory, open a R console and write:

> require("Rcpp")
Loading required package: Rcpp
> Rcpp.package.skeleton("sslgl")
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './sslgl/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world

So, a package source named sslgl was created in the working directory. Now as suggested (I suggest) in the previously mentioned post I do the following. First from the LGL home page I download the file lemon-1.2.1.tar.gz and decompress it. So a directory named lemon-1.2.1 was created. Inside it there is a file named configure, I copy it inside sslgl/src/. Also there is a directory named lemon which I also copy inside sslgl/src/. Then I modify the file inside sslgl/src/ named rcpp_hello_world.cpp putting inside it:

#include "rcpp_hello_world.h"
#include "lemon/list_graph.h"
using namespace lemon ;

SEXP rcpp_hello_world(){
    using namespace Rcpp ;

    int res = 1;

    ListDigraph g;

    ListDigraph::Node u = g.addNode();
    ListDigraph::Node v = g.addNode();
    ListDigraph::Arc  a = g.addArc(u, v);

    int i = countNodes(g);
    int j = countArcs(g);

    Rprintf("num nodes is %d , and num edges is %d \n",i,j);

    return wrap(res) ;
}

Now I try to install the package. So from the linux console inside the working directory I do:

$ R CMD INSTALL sslgl
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘sslgl’ ...
** libs
g++ -shared -o sslgl.so rcpp_hello_world.o -L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib -L/usr/lib64/R/lib -lR
installing to /home/juan/R/x86_64-pc-linux-gnu-library/2.12/sslgl/libs
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘sslgl’
    finding HTML links ... done
    rcpp_hello_world                        html  
    sslgl-package                           html  
** building package indices ...
** testing if installed package can be loaded

* DONE (sslgl)

So, lets see if it works. I open a R console and do:

> require("sslgl")
Loading required package: sslgl
Loading required package: Rcpp
> rcpp_hello_world()
num nodes is 2 , and num edges is 1 
[1] 1

So, it seems to work. But, it work because LGL was previously installed in my system? It work because it does not require another LGL .cc file compiled (i.e. maybe LGL worked as a template)?

In fact, none .cc file inside sslgl/src/lemon/ was compiled to an .o or .so file.

TODO: Answer those questions.

I will try. It seems that a configure file is run by R CMD INSTALL only if it is inside sslgl/ and not inside sslgl/src/. So I make the following trick. I put a configure file inside sslgl/ with the following content:

cd src
./configure
cd ..

Also, I copied all the content of the untared lemon-1.2.1.tar.gz inside sslgl/src/ (if not, I get some error). Then I install via $R CMD INSTALL sslgl and I get:

$ R CMD INSTALL sslgl
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘sslgl’ ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... /usr/bin/awk
checking whether make sets $(MAKE)... yes
checking for style of include used by make... GNU
checking for g++... g++
checking whether the C++ compiler works... yes
checking for C++ compiler default output file name... a.out
checking for suffix of executables... 
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C++ compiler... yes
checking whether g++ accepts -g... yes
checking dependency style of g++... gcc3
checking how to run the C++ preprocessor... g++ -E
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for long long... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking for gcc... gcc
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for a sed that does not truncate output... /bin/sed
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent libraries... pass_all
checking for ar... ar
checking for strip... strip
checking for ranlib... ranlib
checking command to parse /usr/bin/nm -B output from gcc object... ok
checking for dlfcn.h... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking for objdir... .libs
checking if gcc supports -fno-rtti -fno-exceptions... no
checking for gcc option to produce PIC... -fPIC -DPIC
checking if gcc PIC flag -fPIC -DPIC works... yes
checking if gcc static flag -static works... yes
checking if gcc supports -c -o file.o... yes
checking if gcc supports -c -o file.o... (cached) yes
checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking whether stripping libraries is possible... yes
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... no
checking whether to build static libraries... yes
checking for ld used by g++... /usr/bin/ld -m elf_x86_64
checking if the linker (/usr/bin/ld -m elf_x86_64) is GNU ld... yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking for g++ option to produce PIC... -fPIC -DPIC
checking if g++ PIC flag -fPIC -DPIC works... yes
checking if g++ static flag -static works... yes
checking if g++ supports -c -o file.o... yes
checking if g++ supports -c -o file.o... (cached) yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking for doxygen... no
checking for python... yes
checking for gs... yes
checking whether we are using the Intel C++ compiler... no
checking for GLPK... no
checking for CPLEX... no
checking for SOPLEX... no
checking for CLP... no
checking whether to build the additional tools... yes
checking limits.h usability... yes
checking limits.h presence... yes
checking for limits.h... yes
checking sys/time.h usability... yes
checking sys/time.h presence... yes
checking for sys/time.h... yes
checking sys/times.h usability... yes
checking sys/times.h presence... yes
checking for sys/times.h... yes
checking for unistd.h... (cached) yes
checking for an ANSI C-conforming const... yes
checking for inline... inline
checking for size_t... yes
checking whether time.h and sys/time.h may both be included... yes
checking whether struct tm is in sys/time.h or time.h... time.h
checking for ANSI C header files... (cached) yes
checking for gettimeofday... yes
checking for times... yes
checking for ctime_r... yes
configure: creating ./config.status
config.status: creating Makefile
config.status: creating demo/Makefile
config.status: creating cmake/version.cmake
config.status: creating doc/Doxyfile
config.status: creating lemon/lemon.pc
config.status: creating config.h
config.status: creating lemon/config.h
config.status: executing depfiles commands
config.status: executing libtool commands

****************************** SUMMARY ******************************

Package version............... : lemon-1.2.1

C++ compiler.................. : g++
C++ compiles flags............ : -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2

Compiler supports long long... : yes

GLPK support.................. : no
CPLEX support................. : no
SOPLEX support................ : no
CLP support................... : no
CBC support................... : no

Build additional tools........ : yes
Use valgrind for tests........ : no

The packace will be installed in
  /usr/local.

*********************************************************************

Configure complete, now type 'make' and then 'make install'.

** libs
** arch - 
Makefile:1343: warning: overriding commands for target `.cc.o'
/usr/lib64/R/etc/Makeconf:116: warning: ignoring old commands for target `.cc.o'
CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/bash /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing --run aclocal-1.11 -I m4
/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing: line 52: aclocal-1.11: command not found
WARNING: `aclocal-1.11' is missing on your system.  You should only need it if
         you modified `acinclude.m4' or `configure.ac'.  You might want
         to install the `Automake' and `Perl' packages.  Grab them from
         any GNU archive site.
 cd . && /bin/bash /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing --run automake-1.11 --foreign
/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing: line 52: automake-1.11: command not found
WARNING: `automake-1.11' is missing on your system.  You should only need it if
         you modified `Makefile.am', `acinclude.m4' or `configure.ac'.
         You might want to install the `Automake' and `Perl' packages.
         Grab them from any GNU archive site.
CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/bash /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing --run autoconf
/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing: line 52: autoconf: command not found
WARNING: `autoconf' is missing on your system.  You should only need it if
         you modified `configure.ac'.  You might want to install the
         `Autoconf' and `GNU m4' packages.  Grab them from any GNU
         archive site.
/bin/bash ./config.status --recheck
running CONFIG_SHELL=/bin/bash /bin/bash ./configure --no-create --no-recursion
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... /usr/bin/awk
checking whether make sets $(MAKE)... yes
checking for style of include used by make... GNU
checking for g++... g++
checking whether the C++ compiler works... yes
checking for C++ compiler default output file name... a.out
checking for suffix of executables... 
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C++ compiler... yes
checking whether g++ accepts -g... yes
checking dependency style of g++... gcc3
checking how to run the C++ preprocessor... g++ -E
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for long long... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking for gcc... gcc
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for a sed that does not truncate output... /bin/sed
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 3458764513820540925
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent libraries... pass_all
checking for ar... ar
checking for strip... strip
checking for ranlib... ranlib
checking command to parse /usr/bin/nm -B output from gcc object... ok
checking for dlfcn.h... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking for objdir... .libs
checking if gcc supports -fno-rtti -fno-exceptions... no
checking for gcc option to produce PIC... -fPIC -DPIC
checking if gcc PIC flag -fPIC -DPIC works... yes
checking if gcc static flag -static works... yes
checking if gcc supports -c -o file.o... yes
checking if gcc supports -c -o file.o... (cached) yes
checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking whether stripping libraries is possible... yes
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... no
checking whether to build static libraries... yes
checking for ld used by g++... /usr/bin/ld -m elf_x86_64
checking if the linker (/usr/bin/ld -m elf_x86_64) is GNU ld... yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking for g++ option to produce PIC... -fPIC -DPIC
checking if g++ PIC flag -fPIC -DPIC works... yes
checking if g++ static flag -static works... yes
checking if g++ supports -c -o file.o... yes
checking if g++ supports -c -o file.o... (cached) yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking for doxygen... no
checking for python... yes
checking for gs... yes
checking whether we are using the Intel C++ compiler... no
checking for GLPK... no
checking for CPLEX... no
checking for SOPLEX... no
checking for CLP... no
checking whether to build the additional tools... yes
checking limits.h usability... yes
checking limits.h presence... yes
checking for limits.h... yes
checking sys/time.h usability... yes
checking sys/time.h presence... yes
checking for sys/time.h... yes
checking sys/times.h usability... yes
checking sys/times.h presence... yes
checking for sys/times.h... yes
checking for unistd.h... (cached) yes
checking for an ANSI C-conforming const... yes
checking for inline... inline
checking for size_t... yes
checking whether time.h and sys/time.h may both be included... yes
checking whether struct tm is in sys/time.h or time.h... time.h
checking for ANSI C header files... (cached) yes
checking for gettimeofday... yes
checking for times... yes
checking for ctime_r... yes
configure: creating ./config.status

****************************** SUMMARY ******************************

Package version............... : lemon-1.2.1

C++ compiler.................. : g++
C++ compiles flags............ : -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2

Compiler supports long long... : yes

GLPK support.................. : no
CPLEX support................. : no
SOPLEX support................ : no
CLP support................... : no
CBC support................... : no

Build additional tools........ : yes
Use valgrind for tests........ : no

The packace will be installed in
  /usr/local.

*********************************************************************

Configure complete, now type 'make' and then 'make install'.

 /bin/bash ./config.status
config.status: creating Makefile
config.status: creating demo/Makefile
config.status: creating cmake/version.cmake
config.status: creating doc/Doxyfile
config.status: creating lemon/lemon.pc
config.status: creating config.h
config.status: config.h is unchanged
config.status: creating lemon/config.h
config.status: lemon/config.h is unchanged
config.status: executing depfiles commands
config.status: executing libtool commands
Makefile:1343: warning: overriding commands for target `.cc.o'
/usr/lib64/R/etc/Makeconf:116: warning: ignoring old commands for target `.cc.o'
(CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/bash /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing --run autoheader)
/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src/build-aux/missing: line 52: autoheader: command not found
WARNING: `autoheader' is missing on your system.  You should only need it if
         you modified `acconfig.h' or `configure.ac'.  You might want
         to install the `Autoconf' and `GNU m4' packages.  Grab them
         from any GNU archive site.
rm -f stamp-h1
touch config.h.in
cd . && /bin/bash ./config.status config.h
config.status: creating config.h
config.status: config.h is unchanged
make  all-recursive
make[1]: Entering directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
make[2]: Entering directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-arg_parser.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-arg_parser.Tpo -c -o lemon/lemon_libemon_la-arg_parser.lo `test -f 'lemon/arg_parser.cc' || echo './'`lemon/arg_parser.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-arg_parser.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-arg_parser.Tpo -c lemon/arg_parser.cc -o lemon/lemon_libemon_la-arg_parser.o
mv -f lemon/.deps/lemon_libemon_la-arg_parser.Tpo lemon/.deps/lemon_libemon_la-arg_parser.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-base.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-base.Tpo -c -o lemon/lemon_libemon_la-base.lo `test -f 'lemon/base.cc' || echo './'`lemon/base.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-base.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-base.Tpo -c lemon/base.cc -o lemon/lemon_libemon_la-base.o
mv -f lemon/.deps/lemon_libemon_la-base.Tpo lemon/.deps/lemon_libemon_la-base.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-color.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-color.Tpo -c -o lemon/lemon_libemon_la-color.lo `test -f 'lemon/color.cc' || echo './'`lemon/color.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-color.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-color.Tpo -c lemon/color.cc -o lemon/lemon_libemon_la-color.o
mv -f lemon/.deps/lemon_libemon_la-color.Tpo lemon/.deps/lemon_libemon_la-color.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-lp_base.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-lp_base.Tpo -c -o lemon/lemon_libemon_la-lp_base.lo `test -f 'lemon/lp_base.cc' || echo './'`lemon/lp_base.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-lp_base.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-lp_base.Tpo -c lemon/lp_base.cc -o lemon/lemon_libemon_la-lp_base.o
mv -f lemon/.deps/lemon_libemon_la-lp_base.Tpo lemon/.deps/lemon_libemon_la-lp_base.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-lp_skeleton.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-lp_skeleton.Tpo -c -o lemon/lemon_libemon_la-lp_skeleton.lo `test -f 'lemon/lp_skeleton.cc' || echo './'`lemon/lp_skeleton.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-lp_skeleton.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-lp_skeleton.Tpo -c lemon/lp_skeleton.cc -o lemon/lemon_libemon_la-lp_skeleton.o
mv -f lemon/.deps/lemon_libemon_la-lp_skeleton.Tpo lemon/.deps/lemon_libemon_la-lp_skeleton.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/lemon_libemon_la-random.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-random.Tpo -c -o lemon/lemon_libemon_la-random.lo `test -f 'lemon/random.cc' || echo './'`lemon/random.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/lemon_libemon_la-random.lo -MD -MP -MF lemon/.deps/lemon_libemon_la-random.Tpo -c lemon/random.cc -o lemon/lemon_libemon_la-random.o
mv -f lemon/.deps/lemon_libemon_la-random.Tpo lemon/.deps/lemon_libemon_la-random.Plo
/bin/bash ./libtool  --tag=CXX   --mode=compile g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2 -MT lemon/bits/lemon_libemon_la-windows.lo -MD -MP -MF lemon/bits/.deps/lemon_libemon_la-windows.Tpo -c -o lemon/bits/lemon_libemon_la-windows.lo `test -f 'lemon/bits/windows.cc' || echo './'`lemon/bits/windows.cc
libtool: compile:  g++ -DHAVE_CONFIG_H -I. -I. -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT lemon/bits/lemon_libemon_la-windows.lo -MD -MP -MF lemon/bits/.deps/lemon_libemon_la-windows.Tpo -c lemon/bits/windows.cc -o lemon/bits/lemon_libemon_la-windows.o
mv -f lemon/bits/.deps/lemon_libemon_la-windows.Tpo lemon/bits/.deps/lemon_libemon_la-windows.Plo
/bin/bash ./libtool --tag=CXX   --mode=link g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas      -g -O2       -o lemon/libemon.la -rpath /usr/local/lib lemon/lemon_libemon_la-arg_parser.lo lemon/lemon_libemon_la-base.lo lemon/lemon_libemon_la-color.lo lemon/lemon_libemon_la-lp_base.lo lemon/lemon_libemon_la-lp_skeleton.lo lemon/lemon_libemon_la-random.lo lemon/bits/lemon_libemon_la-windows.lo       
libtool: link: ar cru lemon/.libs/libemon.a  lemon/lemon_libemon_la-arg_parser.o lemon/lemon_libemon_la-base.o lemon/lemon_libemon_la-color.o lemon/lemon_libemon_la-lp_base.o lemon/lemon_libemon_la-lp_skeleton.o lemon/lemon_libemon_la-random.o lemon/bits/lemon_libemon_la-windows.o
libtool: link: ranlib lemon/.libs/libemon.a
libtool: link: ( cd "lemon/.libs" && rm -f "libemon.la" && ln -s "../libemon.la" "libemon.la" )
depbase=`echo tools/dimacs-solver.o | sed 's|[^/]*$|.deps/&|;s|\.o$||'`;\
    g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT tools/dimacs-solver.o -MD -MP -MF $depbase.Tpo -c -o tools/dimacs-solver.o tools/dimacs-solver.cc &&\
    mv -f $depbase.Tpo $depbase.Po
/bin/bash ./libtool --tag=CXX   --mode=link g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2   -o tools/dimacs-solver tools/dimacs-solver.o ./lemon/libemon.la 
libtool: link: g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -o tools/dimacs-solver tools/dimacs-solver.o  ./lemon/.libs/libemon.a
depbase=`echo tools/dimacs-to-lgf.o | sed 's|[^/]*$|.deps/&|;s|\.o$||'`;\
    g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT tools/dimacs-to-lgf.o -MD -MP -MF $depbase.Tpo -c -o tools/dimacs-to-lgf.o tools/dimacs-to-lgf.cc &&\
    mv -f $depbase.Tpo $depbase.Po
/bin/bash ./libtool --tag=CXX   --mode=link g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2   -o tools/dimacs-to-lgf tools/dimacs-to-lgf.o ./lemon/libemon.la 
libtool: link: g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -o tools/dimacs-to-lgf tools/dimacs-to-lgf.o  ./lemon/.libs/libemon.a
depbase=`echo tools/lgf-gen.o | sed 's|[^/]*$|.deps/&|;s|\.o$||'`;\
    g++ -DHAVE_CONFIG_H   -I. -I.  -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -MT tools/lgf-gen.o -MD -MP -MF $depbase.Tpo -c -o tools/lgf-gen.o tools/lgf-gen.cc &&\
    mv -f $depbase.Tpo $depbase.Po
/bin/bash ./libtool --tag=CXX   --mode=link g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2   -o tools/lgf-gen tools/lgf-gen.o ./lemon/libemon.la 
libtool: link: g++ -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2 -o tools/lgf-gen tools/lgf-gen.o  ./lemon/.libs/libemon.a
make[2]: Leaving directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
make[1]: Leaving directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
installing to /home/juan/R/x86_64-pc-linux-gnu-library/2.12/sslgl/libs
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘sslgl’
    finding HTML links ... done
    rcpp_hello_world                        html  
    sslgl-package                           html  
** building package indices ...
** testing if installed package can be loaded

* DONE (sslgl)

so, I get some Warnings. Inside sslgl/src/lemon/ there are .o files, so it works in some way, but I don't know if is fine.

Then I uninstall the lemon library doing the following. I open a linux terminal on the directory where I run the make install when I installed the lemon library and run:

$ make uninstall

Then I try starting from a "clean" sslgl source (removed the installed R sslgl package (see here if you want to know how to do that) , then I removed th sslgl source, then I create it again following the steps above):

$ R CMD INSTALL sslgl/
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘sslgl’ ...
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... /bin/mkdir -p
checking for gawk... /usr/bin/awk
checking whether make sets $(MAKE)... yes
checking for style of include used by make... GNU
checking for g++... g++
checking whether the C++ compiler works... yes
checking for C++ compiler default output file name... a.out
checking for suffix of executables... 
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C++ compiler... yes
checking whether g++ accepts -g... yes
checking dependency style of g++... gcc3
checking how to run the C++ preprocessor... g++ -E
checking for grep that handles long lines and -e... /bin/grep
checking for egrep... /bin/grep -E
checking for ANSI C header files... yes
checking for sys/types.h... yes
checking for sys/stat.h... yes
checking for stdlib.h... yes
checking for string.h... yes
checking for memory.h... yes
checking for strings.h... yes
checking for inttypes.h... yes
checking for stdint.h... yes
checking for unistd.h... yes
checking for long long... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking build system type... x86_64-unknown-linux-gnu
checking host system type... x86_64-unknown-linux-gnu
checking for gcc... gcc
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking dependency style of gcc... gcc3
checking for a sed that does not truncate output... /bin/sed
checking for fgrep... /bin/grep -F
checking for ld used by gcc... /usr/bin/ld
checking if the linker (/usr/bin/ld) is GNU ld... yes
checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
checking the name lister (/usr/bin/nm -B) interface... BSD nm
checking whether ln -s works... yes
checking the maximum length of command line arguments... 1572864
checking whether the shell understands some XSI constructs... yes
checking whether the shell understands "+="... yes
checking for /usr/bin/ld option to reload object files... -r
checking for objdump... objdump
checking how to recognize dependent libraries... pass_all
checking for ar... ar
checking for strip... strip
checking for ranlib... ranlib
checking command to parse /usr/bin/nm -B output from gcc object... ok
checking for dlfcn.h... yes
checking whether we are using the GNU C++ compiler... (cached) yes
checking whether g++ accepts -g... (cached) yes
checking dependency style of g++... (cached) gcc3
checking how to run the C++ preprocessor... g++ -E
checking for objdir... .libs
checking if gcc supports -fno-rtti -fno-exceptions... no
checking for gcc option to produce PIC... -fPIC -DPIC
checking if gcc PIC flag -fPIC -DPIC works... yes
checking if gcc static flag -static works... yes
checking if gcc supports -c -o file.o... yes
checking if gcc supports -c -o file.o... (cached) yes
checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking whether stripping libraries is possible... yes
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... no
checking whether to build static libraries... yes
checking for ld used by g++... /usr/bin/ld -m elf_x86_64
checking if the linker (/usr/bin/ld -m elf_x86_64) is GNU ld... yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking for g++ option to produce PIC... -fPIC -DPIC
checking if g++ PIC flag -fPIC -DPIC works... yes
checking if g++ static flag -static works... yes
checking if g++ supports -c -o file.o... yes
checking if g++ supports -c -o file.o... (cached) yes
checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
checking dynamic linker characteristics... GNU/Linux ld.so
checking how to hardcode library paths into programs... immediate
checking for doxygen... no
checking for python... yes
checking for gs... yes
checking whether we are using the Intel C++ compiler... no
checking for GLPK... no
checking for CPLEX... no
checking for SOPLEX... no
checking for CLP... no
checking whether to build the additional tools... yes
checking limits.h usability... yes
checking limits.h presence... yes
checking for limits.h... yes
checking sys/time.h usability... yes
checking sys/time.h presence... yes
checking for sys/time.h... yes
checking sys/times.h usability... yes
checking sys/times.h presence... yes
checking for sys/times.h... yes
checking for unistd.h... (cached) yes
checking for an ANSI C-conforming const... yes
checking for inline... inline
checking for size_t... yes
checking whether time.h and sys/time.h may both be included... yes
checking whether struct tm is in sys/time.h or time.h... time.h
checking for ANSI C header files... (cached) yes
checking for gettimeofday... yes
checking for times... yes
checking for ctime_r... yes
configure: creating ./config.status
config.status: creating Makefile
config.status: creating demo/Makefile
config.status: creating cmake/version.cmake
config.status: creating doc/Doxyfile
config.status: creating lemon/lemon.pc
config.status: creating config.h
config.status: config.h is unchanged
config.status: creating lemon/config.h
config.status: lemon/config.h is unchanged
config.status: executing depfiles commands
config.status: executing libtool commands

****************************** SUMMARY ******************************

Package version............... : lemon-1.2.1

C++ compiler.................. : g++
C++ compiles flags............ : -Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas -g -O2

Compiler supports long long... : yes

GLPK support.................. : no
CPLEX support................. : no
SOPLEX support................ : no
CLP support................... : no
CBC support................... : no

Build additional tools........ : yes
Use valgrind for tests........ : no

The packace will be installed in
  /usr/local.

*********************************************************************

Configure complete, now type 'make' and then 'make install'.

** libs
** arch - 
Makefile:1343: warning: overriding commands for target `.cc.o'
/usr/lib64/R/etc/Makeconf:116: warning: ignoring old commands for target `.cc.o'
make  all-recursive
make[1]: Entering directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
make[2]: Entering directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
make[2]: Leaving directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
make[1]: Leaving directory `/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/src'
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/plain/sslgl/man/sslgl-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘sslgl’
    finding HTML links ... done
    rcpp_hello_world                        html  
    sslgl-package                           html  
** building package indices ...
** testing if installed package can be loaded
Error in library.dynam(lib, package, package.lib) : 
  shared object 'sslgl' not found
ERROR: loading failed
* removing ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12/sslgl’

so, it doesn't work. It seems that I must get involved into the configure and make more deeply.

Salut !

R Learning - Building a self-sufficient package that integrates the C++ LGL via Rcpp - n.1 : Exploring

2011-02-14T13:04:00.012-03:00

First of all, thanks to the mailing list of LGL users, and specially to Alpár Jüttner.

I had previously integrated LGL in R via Rcpp, but using the installation of LGL (Lemon C++ Graph Library) in the system (see here). But now, the idea is to build a R package that uses LGL but do not need the installation of LGL. In other words to build a self-sufficient R package that integrates LGL.
So I start by replicating an interchange in the lemon user mailing list:

First, I send:

Hi, everybody.

I'm just new on this. Few months before I had started to learn R (http://www.r-project.org/). R is nice, but it may be slow. I'm a physicist and normally I do high performance computations. Eventually I get to know that one can integrate C++ codeinto R. As I normally work in complex networks, I was looking for C++ libraries developed for that purpose. In fact, igraph isa package available to R users. So eventually I think to look at the C implementation of it. But I found the C igraph librarya bit "dirty" to deal with. Eventually I also found the Boost Graph Library, but I read about it that it has a step learning curve.Then I found LGL (Lemon Graph Library). It looks pretty nice to work with, and it seems "transparent" so one can understandit easily. Also it seems that can deal with hard computations. So, I decide to try the integration of R with LGL using a Rpackage called Rcpp (which is also awesome!!!). So after a while I had success on it. More precisely, I just got workinga very small and simple program that integrates LGL via Rcpp into R.

I wrote the details of this in my blog. So I want to share it with the LGL community.

http://deliriosderayohauno.blogspot.com/2011/02/lemon-graph-library-lgl-instalation.html
http://deliriosderayohauno.blogspot.com/2011/02/r-learning-building-r-packages-that_468.html

Maybe, some others are walking on the same road. Let my know about that.

Best Regards

Then, Alpár reply:

Hi Juan,

Thanks for sharing your experience. I am not familiar with R, but wenttrough your blogpost and I found it really exciting.

At the end of your post (and at http://stackoverflow.com/) you have aquestion about using LEMON without installing it. Is it a general issueusing Rcpp, or something LEMON specific?

In general, LEMON headers must be included like#include, indeed, but this shouldn't cause any problemfor you - simply create a lemon subdirectory within your include dir andput the lemon headers there.

Regards,Alpár
P.S. It was nice to find other happy users following the links in yourpost.

Then, I reply:

Hi Alpár,

Thanks for your kind response and interest. If I'll try to answer yourquestion maybe I can formulate more precisely my own. When youwrite a R package there are 2 main subdirectories, one named R/and other src/. Inside R/ you put all your .R files (the files with the Rcode) and inside src/ you put all your .cpp and .h files. Eventuallyyou build the package with the R builder which will compile and link the.cpp and .h files in src/, in libraries files .so that you can "load"from the R code.

Now, that seems to be the way when you use your own .cpp and .hfiles. In the case of using Lemon I think in two possibilities:

1) Installing it, so all the .h and (may be .so, I don't know if there are someof them) files will be some where in the systems accessible via the system PATHs. So one can use the tools provided by the library by meansof a simple line like:

#include <lemon/dijkstra.h>

in your/s .cpp file/s. And this is what I had done. I first try this options becauseI don't know what the installation of the Lemon library does. So maybe theprocess of installation is necessary in order that the Lemon library works.

2) Now, I'm thinking in this other option (which I do not test yet). Just copyingthe /lemon/ directory inside the src/ directory and access the .h files trougha line like (for example):

#include "lemon/dijkstra.h"

that is, now the .h files (I don't know what happens if there are or must be .so files in the Lemon library) are not accessed via the system PATHs, butdirectly inside the src/ directory. This option is in some way better for me(and maybe for others) if it works. Why? Simply, in this way one can builda self-sufficient R package that can be easily installed in other systemsthat uses R via a simple R command from a R console like this (suppose that the package is named LemonPkg):

> install.packages("LemonPkg")

and that is !!! You can use all the power of R (the main power ofR is that it integrates conveniently a lot of libraries, also it seems a nice language to work with) and Lemon in a very easy way. But only if this second option works. I will try this at some point.

Best Regards

P.S.: Sorry if my mail is so extent.

Then, Alpár reply:

Hi,

... in response to 2)

This should basically work, but with the following reservations:
   * Each lemon header includes , which in not in the
   tarball, but instead it is generated from lemon/config.h.in or
   from lemon/config.h.cmake (depending on the build system you
   use) during the configuration phase.
     * The easiest solution is to have cmake or ./configure
     generate this file and use that, or
     * a simple empty file will also serve quite well. (At the
     price that some of the tools won't be able to handle the
     'long long' type and the LP interface will be disables)
   * There are some .cc files you should also compile. The only
   crucial is base.cc, but color.cc (for the graphToEps() tool)
   might also be good. All the remaining .cc files are of little
   use for you (they are used by the LP interface and by
   ArgParser).

Regards,
Alpar

Now, what is LP? I found this (read section CLP which also link to this).So, as I see, there are two main directions to follow:

i) The simplest: avoid using lemon/config.h (empty file) with the cost of loosing 'long long' type and LP tool.
2) A harder one: intervene the C++ compilation that R does when building the package (I know that this can be done in some way) and try to use the lemon/config.h.cmake or lemon/config.h.in
TODO: Explore this possibilities

So taking in consideration the 2) possibility. Inspecting a little the Writing R Extensions there "speaks" about a Makefile and Makevars files.

So, in the R side we have:

Makevars
Makefile

In the LGL side we have:

config.h.in
config.h.cmake
cmake
./configure

Keywords: POSIX, make, configure, Makevars, Autoconf,...

Now I found in Writing R Extensions (Section 1.2 Configure and cleanup) the following:

If your package needs some system-dependent configuration before installation you can include an executable (Bourne shell) script ‘configure’ in your package which (if present) isexecuted by R CMD INSTALL before any other action is performed. This can be a script createdby the Autoconf mechanism, but may also be a script written by yourself. Use this to detectif any nonstandard libraries are present such that corresponding code in the package can bedisabled at install time rather than giving error messages when the package is compiled or used.To summarize, the full power of Autoconf is available for your extension package (includingvariable substitution, searching for libraries, etc.).

so, it seems that maybe the configure file inside the LGL source could be automatically ran and do the proper configuration required by the lemon/config.h

Salut !

R Learning - Experimenting with Roxygen: R,Rcpp,LGL via Roxygen - n.3

2011-02-13T19:30:00.005-03:00

In two previous posts (this and this) I was experimenting with the construction of packages using Literate Programming via Roxygen.

In the other side, I also was experimenting with building R packages that integrates Lemon Graph Library (LGL) C++ code via Rcpp (this post).

Now the challenge is to build a R package that integrates LGL C++ code via Rcpp using Roxygen.

How will I do it? Well, I think that the shortest way is to use as a starting point the source package named pkgwithlgl which development I discuss in the post mentionated above related to the integration of LGL via Rcpp. Also to use as guide the .R files used in the other mentioned post above about the use of roxygen.

TODO ... (the package is running, it remains to determine which things roxygen predetermines in the DESCRIPTION and NAMESPACE files). This may be useful for this goal. Notice that Depends is not the same as Import, for example a R package may depend on the Rcpp package because it includes Rcpp.h, but if does not use R code inside Rcpp so there is no need to import Rcpp.

TODO: There remains: i) Try to learn some IDE as ESS or Eclipse-StatET. ii) See if there is something similar to roxygen for the src/ code in a R package.

R Learning - Experimenting with Roxygen - n.2

2011-02-13T12:58:00.012-03:00

In a previous post I take a little experiment with a simple Roxygen example (the first one that appears in its vignette on CRAN). Now I will try with the second example. So I pick a working directory and create the following files:

First one named pseudoprime-package.R containing:

#' Tests pseudoprimality by Fermat's little theorem.
#'
#' \tabular{ll}{
#' Package: \tab pseudoprime\cr
#' Type: \tab Package\cr
#' Version: \tab 0.1\cr
#' Date: \tab 2008-08-24\cr
#' License: \tab GPL (>= 2)\cr
#' LazyLoad: \tab yes\cr
#' }
#'
#' Using the Fermat primality test, pseudoprime checks for primes
#' probabilistically; the test is fooled every time by Carmichael
#' numbers.
#'
#' \code{\link{is.pseudoprime}} checks a number \code{n} for
#' pseudoprimality, applying Fermat's test \code{times} times.
#'
#' @name pseudoprime-package
#' @aliases pseudoprime
#' @docType package
#' @title Tests pseudoprimality by Fermat's little theorem
#' @author Peter Danenberg \email{pcd@@roxygen.org}
#' @references
#' \url{http://en.wikipedia.org/wiki/Fermat's_little_theorem}
#' @keywords package
#' @seealso \code{\link{is.pseudoprime}}
#' @examples
#' is.pseudoprime(13, 4)
roxygen()

another named fermat.R containing:

#' Test an integer for primality with Fermat's little theorem.
#'
#' Fermat's little theorem states that if \eqn{n} is a prime
#' number and \eqn{a} is any positive integer less than \eqn{n},
#' then \eqn{a} raised to the \eqn{n}th power is congruent to
#' \eqn{a\ modulo\ n}{a modulo n}.
#'
#' @param n the integer to test for primality
#' @return Whether the integer passes the Fermat test
#' for a randomized \eqn{0 < a < n}
#' @callGraphPrimitives
#' @note \code{fermat.test} doesn't work for integers above
#' approximately fifteen because modulus loses precision.
#' @references
#' \url{http://en.wikipedia.org/wiki/Fermat's_little_theorem}
#' @author Peter Danenberg \email{pcd@@roxygen.org}
fermat.test <- function(n) {
    a <- floor(runif(1, min=1, max=n))
    a ^ n %% n == a
}

and finally another named pseudoprime.R containing:

#' @include fermat.R
roxygen()

#' Check an integer for pseudo-primality to an arbitrary
#' precision.
#'
#' A number is pseudo-prime if it is probably prime, the basis
#' of which is the probabilistic Fermat test; if it passes two
#' such tests, the chances are better than 3 out of 4 that
#' \eqn{n} is prime.
#'
#' @param n the integer to test for pseudoprimality.
#' @param times the number of Fermat tests to perform
#' @return Whether the number is pseudoprime
#' @export
#' @seealso \code{\link{fermat.test}}
#' @references Abelson, Hal; Jerry Sussman, and Julie Sussman.
#' Structure and Interpretation of Computer Programs.
#' Cambridge: MIT Press, 1984.
#' @author Peter Danenberg \email{pcd@@roxygen.org}
#' @examples
#' is.pseudoprime(13, 4) # TRUE most of the time
is.pseudoprime <- function(n, times) {
    if (times == 0) TRUE
    else if (fermat.test(n)) is.pseudoprime(n, times - 1)
    else FALSE
}

Notice that the first file (pseudoprime-package.R) contains no R code, It is just something that Roxygen eats in order to create the pseudoprime-package.Rd file (and something more?). The third file (pseudoprime.R) contains the "main" code that will be exposed to the package user, this file "includes" (import) code stored in the second file (fermat.R).

Now lets proceed to build a roxygenized package from this files. I open a R console in the working directory and run:

> files <- c("pseudoprime-package.R","pseudoprime.R","fermat.R")
> package.skeleton("pseudoprimePackage",code_files=files,force=TRUE)
Error in eval(expr, envir, enclos) : could not find function "roxygen"
> require("roxygen")
Loading required package: roxygen
Loading required package: digest
> package.skeleton("pseudoprimePackage",code_files=files,force=TRUE)
Creating directories ...
Creating DESCRIPTION ...
Creating Read-and-delete-me ...
Copying code files ...
Making help files ...
Done.
Further steps are described in './pseudoprimePackage/Read-and-delete-me'.

It creates a package with the corresponding .R files in the R. Inside the man directory there are 3 files: fermat.test.Rd, is.pseudoprime.Rd and pseudoprimePackage-package.Rd. The first one contains:

\name{fermat.test}
\alias{fermat.test}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
%%  ~~function to do ... ~~
}
\description{
%%  ~~ A concise (1-5 lines) description of what the function does. ~~
}
\usage{
fermat.test(n)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
  \item{n}{
%%     ~~Describe \code{n} here~~
}
}
\details{
%%  ~~ If necessary, more details than the description above ~~
}
\value{
%%  ~Describe the value returned
%%  If it is a LIST, use
%%  \item{comp1 }{Description of 'comp1'}
%%  \item{comp2 }{Description of 'comp2'}
%% ...
}
\references{
%% ~put references to the literature/web site here ~
}
\author{
%%  ~~who you are~~
}
\note{
%%  ~~further notes~~
}

%% ~Make other sections like Warning with \section{Warning }{....} ~

\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
}
\examples{
##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--    or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function (n) 
{
    a <- floor(runif(1, min = 1, max = n))
    a^n\%\%n == a
  }
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line

the second one contains:

\name{is.pseudoprime}
\alias{is.pseudoprime}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
%%  ~~function to do ... ~~
}
\description{
%%  ~~ A concise (1-5 lines) description of what the function does. ~~
}
\usage{
is.pseudoprime(n, times)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
  \item{n}{
%%     ~~Describe \code{n} here~~
}
  \item{times}{
%%     ~~Describe \code{times} here~~
}
}
\details{
%%  ~~ If necessary, more details than the description above ~~
}
\value{
%%  ~Describe the value returned
%%  If it is a LIST, use
%%  \item{comp1 }{Description of 'comp1'}
%%  \item{comp2 }{Description of 'comp2'}
%% ...
}
\references{
%% ~put references to the literature/web site here ~
}
\author{
%%  ~~who you are~~
}
\note{
%%  ~~further notes~~
}

%% ~Make other sections like Warning with \section{Warning }{....} ~

\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
}
\examples{
##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--    or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function (n, times) 
{
    if (times == 0) 
        TRUE
    else if (fermat.test(n)) 
        is.pseudoprime(n, times - 1)
    else FALSE
  }
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line

and finally the third one contains:

\name{pseudoprimePackage-package}
\alias{pseudoprimePackage-package}
\alias{pseudoprimePackage}
\docType{package}
\title{
What the package does (short line)
~~ package title ~~
}
\description{
More about what it does (maybe more than one line)
~~ A concise (1-5 lines) description of the package ~~
}
\details{
\tabular{ll}{
Package: \tab pseudoprimePackage\cr
Type: \tab Package\cr
Version: \tab 1.0\cr
Date: \tab 2011-02-13\cr
License: \tab What license is it under?\cr
LazyLoad: \tab yes\cr
}
~~ An overview of how to use the package, including the most important ~~
~~ functions ~~
}
\author{
Who wrote it

Maintainer: Who to complain to <yourfault@somewhere.net>
~~ The author and/or maintainer of the package ~~
}
\references{
~~ Literature or other references for background information ~~
}
~~ Optionally other standard keywords, one per line, from file KEYWORDS in ~~
~~ the R documentation directory ~~
\keyword{ package }
\seealso{
~~ Optional links to other man pages, e.g. ~~
~~ \code{\link[<pkg>:<pkg>-package]{<pkg>}} ~~
}
\examples{
~~ simple examples of the most important functions ~~
}

Now, lets roxygenize the package. In a linux console inside the container directory (the one that contains the recently created package) I run:

$ R CMD roxygen -d pseudoprimePackage
Loading required package: digest
Writing fermat.test to pseudoprimePackage/man/fermat.test.Rd
Writing pseudoprime-package to pseudoprimePackage/man/pseudoprime-package.Rd
Writing is.pseudoprime to pseudoprimePackage/man/is.pseudoprime.Rd
Writing namespace directives to pseudoprimePackage/NAMESPACE 
Merging collate directive with pseudoprimePackage/DESCRIPTION to pseudoprimePackage/DESCRIPTION

Now (I forgot to put the version before roxygenize it) in the DESCRIPTION file one finds:

Package: pseudoprimePackage
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-13
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What license is it under?
LazyLoad: yes
Collate: 'fermat.R' 'pseudoprime-package.R' 'pseudoprime.R'

Notice the extra line "Collate" which seems to determine the appropriate order of collation. Then inside fermat.test.Rd one finds:


\name{fermat.test}
\alias{fermat.test}
\title{Test an integer for primality with Fermat's little theorem.}
\usage{fermat.test(n)}
\description{Test an integer for primality with Fermat's little theorem.}
\details{Fermat's little theorem states that if \eqn{n} is a prime
number and \eqn{a} is any positive integer less than \eqn{n},
then \eqn{a} raised to the \eqn{n}th power is congruent to
\eqn{a\ modulo\ n}{a modulo n}.}
\value{Whether the integer passes the Fermat test
for a randomized \eqn{0 < a < n}}
\note{\code{fermat.test} doesn't work for integers above
approximately fifteen because modulus loses precision.}
\references{\url{http://en.wikipedia.org/wiki/Fermat's_little_theorem}}
\author{Peter Danenberg \email{pcd@roxygen.org}}
\arguments{\item{n}{the integer to test for primality}}

inside is.pseudoprime.Rd one finds:

\name{is.pseudoprime}
\alias{is.pseudoprime}
\title{Check an integer for pseudo-primality to an arbitrary...}
\usage{is.pseudoprime(n, times)}
\description{Check an integer for pseudo-primality to an arbitrary
precision.}
\details{A number is pseudo-prime if it is probably prime, the basis
of which is the probabilistic Fermat test; if it passes two
such tests, the chances are better than 3 out of 4 that
\eqn{n} is prime.}
\value{Whether the number is pseudoprime}
\seealso{\code{\link{fermat.test}}}
\references{Abelson, Hal; Jerry Sussman, and Julie Sussman.
Structure and Interpretation of Computer Programs.
Cambridge: MIT Press, 1984.}
\author{Peter Danenberg \email{pcd@roxygen.org}}
\arguments{\item{n}{the integer to test for pseudoprimality.}
\item{times}{the number of Fermat tests to perform}}
\examples{is.pseudoprime(13, 4) # TRUE most of the time}

pseudoprimePackage-package.Rd remains the same, and there appears other file named pseudoprime-package.Rd which contains:

\name{pseudoprime-package}
\title{Tests pseudoprimality by Fermat's little theorem}
\description{Tests pseudoprimality by Fermat's little theorem.}
\details{\tabular{ll}{
Package: \tab pseudoprime\cr
Type: \tab Package\cr
Version: \tab 0.1\cr
Date: \tab 2008-08-24\cr
License: \tab GPL (>= 2)\cr
LazyLoad: \tab yes\cr
}

Using the Fermat primality test, pseudoprime checks for primes
probabilistically; the test is fooled every time by Carmichael
numbers.

\code{\link{is.pseudoprime}} checks a number \code{n} for
pseudoprimality, applying Fermat's test \code{times} times.}
\alias{pseudoprime}
\docType{package}
\author{Peter Danenberg \email{pcd@roxygen.org}}
\references{\url{http://en.wikipedia.org/wiki/Fermat's_little_theorem}}
\keyword{package}
\seealso{\code{\link{is.pseudoprime}}}
\examples{is.pseudoprime(13, 4)}

So, there is something to remark. Initially the package.skeleton(...) function creates 3 man files (fermat.test.Rd, is.pseudoprime.Rd and pseudoprimePackage-package.Rd)two of them related to R functions (the files fermat.test.Rd and is.pseudoprime.Rd), the other one (pseudoprimePackage-package.Rd) dedicated to the description of the package. Then, roxygenize replace two of them (the corresponding to the R functions: fermat.test.Rd and is.pseudoprime.Rd), left untouched pseudoprimePackage-package.Rd and create a fourth one pseudoprime-package.Rd which transcript the roxygen code inside pseudoprime-package.R, so the idea is that this fourth file replaces in its function of describing the package to the file pseudoprimePackage-package.Rd. So, one file become useless. How to avoid this? The way is to name the .R file that trough the roxygenation eventually lead to the .Rd file that becomes the package description. In other words using the right names in the call of package.skeleton(...) and in the roxygenation.Iin this case the right thing would be to construct a source package via (in a R console):

> package.skeleton("pseudoprime",code_files=files,force=TRUE)
Creating directories ...
Creating DESCRIPTION ...
Creating Read-and-delete-me ...
Copying code files ...
Making help files ...
Done.
Further steps are described in './pseudoprime/Read-and-delete-me'.

and then (in a linux console):

$ R CMD roxygen -d pseudoprime
Loading required package: digest
Writing fermat.test to pseudoprime/man/fermat.test.Rd
Writing pseudoprime-package to pseudoprime/man/pseudoprime-package.Rd
Writing is.pseudoprime to pseudoprime/man/is.pseudoprime.Rd
Writing namespace directives to pseudoprime/NAMESPACE 
Merging collate directive with pseudoprime/DESCRIPTION to pseudoprime/DESCRIPTION

so, now the source package directory name is pseudoprime, and inside man one finds only 3 files: fermat.test.Rd, is.pseudoprime.Rd, and pseudoprime-package.Rd. All of them with content determined via the comment directives that interpret roxygen in the source .R files. In other words, the .Rd file containing the package description originally created by package.skeleton(...) was replaced by a file of the same name created by the roxygenization.

Now lets install the package in order to see if it works. So I proceed in a linux console in the working directory that contains the source package:

$ R CMD INSTALL pseudoprime
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘pseudoprime’ ...
** R
** inst
** preparing package for lazy loading
Error in eval(expr, envir, enclos) : could not find function "roxygen"
Error : unable to load R code in package 'pseudoprime'
ERROR: lazy loading failed for package ‘pseudoprime’
* removing ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12/pseudoprime’

so, it doesn't work. It seems that the first Error has to do with a call to the function roxygen() which is not imported. It seems that for some reason after R comments that serves as roxygen commands there need to be a NULL (a R "command" that does nothing). A way to implement this is to call the function roxygen() which returns NULL. Lets see what happens if I replace the roxygen() calls with NULL.


R CMD INSTALL pseudoprime/
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘pseudoprime’ ...
** R
** inst
** preparing package for lazy loading
** help
*** installing help indices
  converting help for package ‘pseudoprime’
    finding HTML links ... done
    fermat.test                             html  
    is.pseudoprime                          html  
    pseudoprime-package                     html  
** building package indices ...
** testing if installed package can be loaded

* DONE (pseudoprime)

it seems to work. Lets se now if it works from a R console:

> require("pseudoprime")
Loading required package: pseudoprime
> is.pseudoprime(13,4)
[1] TRUE
> fermat.test(13)
Error: could not find function "fermat.test"

So, as one can see, it works and only the exported function is available.

TODO: Now the next challenge is to use roxygen and Rcpp.package.skeleton() to build a package that integrates C++ code, and eventually LGL C++ code.

Salut !

R Learning - Experimenting with Roxygen - n.1

2011-02-13T12:03:00.006-03:00

In this post, I will write a logbook about trying some examples that uses Roxygen. I will base my experiment on the roxygen vignette where there are 2 examples. Lets start with the simplest one. I pick a working directory, and inside it I create a file named hello-roxygen.R with the following content:

#' A package to check Roxygen's sanity
#' @name helloRoxygen-package
#' @docType package
NA

Then I open a R console on the working directory and run:

> require("roxygen")
Loading required package: roxygen
Loading required package: digest
> package.skeleton("hello-roxygen",code_files="hello-roxygen.R",force=TRUE)
Creating directories ...
Creating DESCRIPTION ...
Creating Read-and-delete-me ...
Copying code files ...
Making help files ...
Done.
Further steps are described in './hello-roxygen/Read-and-delete-me'.

So, inside the working directory appears a directory named hello-roxygen which correspond to a source package. Inside it there are 2 files (DESCRIPTION and Read-and-delete-me) and 2 directories (man and R). I will focus in the content of DESCRIPTION and man/hello-roxygen.Rd. So, the content of DESCRIPTION is:

Package: hello-roxygen
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-13
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What license is it under?
LazyLoad: yes

and the content of hello-roxygen.Rd is:

\name{hello-roxygen-package}
\alias{hello-roxygen-package}
\alias{hello-roxygen}
\docType{package}
\title{
What the package does (short line)
~~ package title ~~
}
\description{
More about what it does (maybe more than one line)
~~ A concise (1-5 lines) description of the package ~~
}
\details{
\tabular{ll}{
Package: \tab hello-roxygen\cr
Type: \tab Package\cr
Version: \tab 1.0\cr
Date: \tab 2011-02-13\cr
License: \tab What license is it under?\cr
LazyLoad: \tab yes\cr
}
~~ An overview of how to use the package, including the most important ~~
~~ functions ~~
}
\author{
Who wrote it

Maintainer: Who to complain to <yourfault@somewhere.net>
~~ The author and/or maintainer of the package ~~
}
\references{
~~ Literature or other references for background information ~~
}
~~ Optionally other standard keywords, one per line, from file KEYWORDS in ~~
~~ the R documentation directory ~~
\keyword{ package }
\seealso{
~~ Optional links to other man pages, e.g. ~~
~~ \code{\link[<pkg>:<pkg>-package]{<pkg>}} ~~
}
\examples{
~~ simple examples of the most important functions ~~
}

Now, I run in the R console the appropriate roxygen commands:

> roxygenize("hello-roxygen",roxygen.dir="hello-roxygen",copy.package=FALSE,unlink.target=FALSE)
Writing helloRoxygen-package to hello-roxygen/man/helloRoxygen-package.Rd
Writing namespace directives to hello-roxygen/NAMESPACE 
Merging collate directive with hello-roxygen/DESCRIPTION to hello-roxygen/DESCRIPTION

Now lets look if some changes occurs in the previous mentioned files. Inside DESCRIPTION one can find:

Package: hello-roxygen
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-13
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What license is it under?
LazyLoad: yes
Collate: 'hello-roxygen.R'

so, it is the same file as before but with an extra line:

Collate: 'hello-roxygen.R'

I don't know what this line minds, but in Writin R extensions there is written about this the following:

An ‘Collate’ field can be used for controlling the collation order for the R code files in a package when these are processed for package installation. The default is to collate according to the ‘C’ locale. If present, the collate specification must list all R code files in the package (taking possible OS-specific subdirectories into account, see Package subdirectories) as a whitespace separated list of file paths relative to the R subdirectory. Paths containing white space or quotes need to be quoted. An OS-specific collation field (‘Collate.unix’ or ‘Collate.windows’) will be used instead of ‘Collate’.

Now, inside the man directory there are two files: hello-roxygen-package.Rd and helloRoxygen-package.Rd. Inside hello-roxygen-package.Rd one finds:

\name{hello-roxygen-package}
\alias{hello-roxygen-package}
\alias{hello-roxygen}
\docType{package}
\title{
What the package does (short line)
~~ package title ~~
}
\description{
More about what it does (maybe more than one line)
~~ A concise (1-5 lines) description of the package ~~
}
\details{
\tabular{ll}{
Package: \tab hello-roxygen\cr
Type: \tab Package\cr
Version: \tab 1.0\cr
Date: \tab 2011-02-13\cr
License: \tab What license is it under?\cr
LazyLoad: \tab yes\cr
}
~~ An overview of how to use the package, including the most important ~~
~~ functions ~~
}
\author{
Who wrote it

Maintainer: Who to complain to <yourfault@somewhere.net>
~~ The author and/or maintainer of the package ~~
}
\references{
~~ Literature or other references for background information ~~
}
~~ Optionally other standard keywords, one per line, from file KEYWORDS in ~~
~~ the R documentation directory ~~
\keyword{ package }
\seealso{
~~ Optional links to other man pages, e.g. ~~
~~ \code{\link[<pkg>:<pkg>-package]{<pkg>}} ~~
}
\examples{
~~ simple examples of the most important functions ~~
}

so, this is the same file that there exist before applying the roxygenize(...) command, it was untouched . Inside helloRoxygen-package.Rd one finds:

\name{helloRoxygen-package}
\alias{helloRoxygen-package}
\title{A package to check Roxygen's sanity...}
\description{A package to check Roxygen's sanity}
\docType{package}

so, this is a new file created by roxygenize(...), and it contains the expression of the directives written in the hello-roxygen.R file.
This example package does not have code of any kind (not R code, not C++, etc), so there is no reason for to install it in order to test it.

TODO: Try with the next example in the roxygen vignette.

Salut !

R Utilities - the cxxPack package

2011-02-12T21:53:00.002-03:00

I don't know exactly what this package does. But it seems that facilitates building packages that uses C++ code via Rcpp.

Here a link to the package on CRAN.

TODO: Check if it is useful.

Salut !

R statistics and C++ - IDEs, GUIs, etc...

2011-02-12T12:28:00.017-03:00

Now, it is time to think around IDEs. Some months before I have worked with .NET framework for C#. I found this experience grateful. Normally I work using vi, that is because I normally looks for simplicity. But it happens that simplicity maybe provided by a nice IDE (integrated development environment). It requires to learn something more, and also (frequently) to pick from several options, but I begin to think that it may worth the effort.

So, for the moment I just have some names (these are not all IDEs, there are also tools that may become part of some IDE). I list them here:

ESS
ECLIPSE with StatET
Roxygen
Sweave
Gedit + RGedit plugin + Snippets plugin

I need to learn to distinguish terms. IDE, framework and GUI are not the same. Now I'm trying to install ECLIPSE and its plugin StatET. Lets see what happens... Well it is working (maybe the configuration is not in its best). But I notice something that I don't like. It requires a lot of resources of my laptop. Maybe this post can be useful.

TODO: Now the goal is to understand the function and interplay between R, Roxygen, Eclipse, and StatET.

Useful links:

Roxygen Tutorial (presentation)
Tutorial: Literate programming with Roxygen at userR! 2010
Rd2roxygen: Convert Rd to roxygen documentation (video, ESS)
S-Plus/R with ESS (tutorial)
[StatET-user] tip for StatET users new to Eclipse (at the StatET mailing list)
Eclipse And Java: Free Video Tutorials
Namespaces ...

Now taking in account that I also want to code in C++ (and eventually integrate it on R) I must to think about IDE's that are functional to C++ also, and evenly to R and C++ at the same time.

This presentation gives an overview of the topic.

This post in stack overflow "talks" about debugging R and C++ code at the same time.

Here some info about using ESS (Emacs Speaks Statistics) with R. Also speaks about debugging R code within R.
TODO: Is this mechanism also usable to debug C++ code integrated with R?

There are also C++ specific IDEs. Codelite sounds in my head. But I think that after all maybe Emacs is the best choice if I will code R and C++ because it can deal with both (and I think that it can do that at the same time).

Salut !

R Learning - Building R packages that integrates C++ via Rcpp - n.4 (linking with LGL)

2011-02-11T15:21:00.004-03:00

So, as I stated before, it is time to see if I can integrate C++ code that uses the Lemon Graph Library into R via Rcpp (see these sequel of previous posts: here, here, here and here).

In my first approach I will not use modules (a tool provided by Rcpp). So I start a new pakage skeleton from a R console:

> require("Rcpp")
Loading required package: Rcpp
> Rcpp.package.skeleton("pkgwithlgl")
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './pkgwithlgl/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world

Now inside the directory where I run the R console I found a directory named pkgwithlgl which is the source of this "experimental" package (the directory's name correspond to package with LGL (Lemon Graph Library)).

Now, the main idea is to edit rcpp_hello_world.cpp (stored in the src) so to implement what I do here. More precisely, I change that file from this:

#include "rcpp_hello_world.h"

SEXP rcpp_hello_world(){
    using namespace Rcpp ;

    CharacterVector x = CharacterVector::create( "foo", "bar" )  ;
    NumericVector y   = NumericVector::create( 0.0, 1.0 ) ;
    List z            = List::create( x, y ) ;

    return z ;
}

into this:

#include "rcpp_hello_world.h"
#include <lemon/list_graph.h>
using namespace lemon ;

SEXP rcpp_hello_world(){
    using namespace Rcpp ;

    int res = 1;

    ListDigraph g;

    ListDigraph::Node u = g.addNode();
    ListDigraph::Node v = g.addNode();
    ListDigraph::Arc  a = g.addArc(u, v);

    int i = countNodes(g);
    int j = countArcs(g);

    Rprintf("num nodes is %d , and num edges is %d \n",i,j);

    return wrap(res) ;
}

Lets see what happens when I try to install the package. So in a linux console in the container directory of pkgwithlgl I run:

$ R CMD INSTALL pkgwithlgl
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘pkgwithlgl’ ...
** libs
g++ -I/usr/share/R/include   -I"/usr/local/lib/R/site-library/Rcpp/include"   -fpic  -O3 -pipe  -g -c rcpp_hello_world.cpp -o rcpp_hello_world.o
g++ -shared -o pkgwithlgl.so rcpp_hello_world.o -L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib -L/usr/lib64/R/lib -lR
installing to /home/juan/R/x86_64-pc-linux-gnu-library/2.12/pkgwithlgl/libs
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/pkgwithlgl/man/pkgwithlgl-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/pkgwithlgl/man/pkgwithlgl-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘pkgwithlgl’
    finding HTML links ... done
    pkgwithlgl-package                      html  
    rcpp_hello_world                        html  
** building package indices ...
** testing if installed package can be loaded

* DONE (pkgwithlgl)

so It seems that the package was installed. Lets se if it works:

> require("pkgwithlgl")
Loading required package: pkgwithlgl
Loading required package: Rcpp
> rcpp_hello_world()
num nodes is 2 , and num edges is 1
[1] 1

It works !!!

Now I'm answering myself. What happens if I upload this package to (forexample) the CRAN repository and other one install it (without the installation of the LGL package). Will it work this package to him?

TODO: Answer that question.

Salut !

R Learning - Building R packages that integrates C++ via Rcpp - n.3

2011-02-11T11:13:00.009-03:00

In a previous post I stated that remains to explore the example about how to develop a package, that one obtains calling the Rcpp.package.skeleton() function of the Rcpp package in the case that modules are used.

So, I start from an R console typing:

> require("Rcpp")
Loading required package: Rcpp
> ?Rcpp.package.skeleton

So, the man of the Rcpp.package.skeleton() function appears, and in the end it suggest the following example (which I type in the R console):

> Rcpp.package.skeleton( "testmod", module = TRUE )
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './testmod/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world
 >> copied the example module

So, it seems that the source example package was created. Lets take a look at the directory from where I run the R console. There appears a directory called testmod which corresponds to the source of the example package. Inside it one founds:

$ ls
DESCRIPTION  man  NAMESPACE  R  Read-and-delete-me  src

that is, 3 files and 3 directories. Lets look first the files. Inside DESCRIPTION one finds:

Package: testmod
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-11
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What Licence is it under ?
LazyLoad: yes
Depends: methods, Rcpp (>= 0.9.0)
LinkingTo: Rcpp

which is a little different from the example that does not uses modules (in this case it depends also on methods). Then, inside NAMESPACE one finds:

useDynLib(testmod)
exportPattern("^[[:alpha:]]+")
import( Rcpp )

which is also different from the example that does not uses modules. In this case appears an extra line:

import( Rcpp )

which (as stated here) its function is to import all the exported variables of the specified package (Rcpp in this case). So it seems that a packages that uses modules requires some functionality provided by the package Rcpp (and not simply the inclusion of the Rcpp.h header). So in the first case, it seems that the Rcpp package needs to be there in order to provide access to Rcpp.h, but in the second case, it is also required to require the Rcpp package. The Read-and-delete-me file is the same as in the other examples. Now lets look inside the directories. First we look inside R and found:

$ ls
rcpp_hello_world.R  zzz.R

that is 2 files. Inside rcpp_hello_world.R one found:

rcpp_hello_world <- function(){
        .Call( "rcpp_hello_world", PACKAGE = "testmod" )
}

the same that there is in the example that does not uses modules. Inside zzz.R one founds:

# grab the namespace
.NAMESPACE <- environment()

# dummy module, will be replace later
yada <- new( "Module" )

.onLoad <- function(pkgname, libname){
        # load the module and store it in our namespace
        unlockBinding( "yada" , .NAMESPACE )
        assign( "yada",  Module( "yada" ), .NAMESPACE )
        lockBinding( "yada", .NAMESPACE )
}

I'm not sure what it is, maybe some can be understood from here (the Rcpp modules vignettes). I will pospone a better understanding of this until I'll install the package and play with it.

Inside the src directory one finds:

$ ls
Makevars  Makevars.win  rcpp_hello_world.cpp  rcpp_hello_world.h  rcpp_module.cpp

I will focus on only Makevars and rcpp_module.cpp (the other does not changes from the example that does not uses modules). So, inside rcpp_module.cpp one finds:

#include <Rcpp.h>

std::string hello() {
        throw std::range_error( "boom" ) ;
}

int bar( int x){
        return x*2 ;
}
        
double foo( int x, double y){
        return x * y ;
}

void bla( ){
        Rprintf( "hello\\n" ) ;
}

void bla1( int x){
        Rprintf( "hello (x = %d)\\n", x ) ;
}
  
void bla2( int x, double y){
        Rprintf( "hello (x = %d, y = %5.2f)\\n", x, y ) ;
}

class World {
public:
    World() : msg("hello"){}
    void set(std::string msg) { this->msg = msg; }
    std::string greet() { return msg; }

private:
    std::string msg;
};

RCPP_MODULE(yada){
        using namespace Rcpp ;
                          
        function( "hello" , &hello  , "documentation for hello " ) ;
        function( "bla"   , &bla    , "documentation for bla " ) ;
        function( "bla1"  , &bla1   , "documentation for bla1 " ) ;
        function( "bla2"  , &bla2   , "documentation for bla2 " ) ;
        
        // with formal arguments specification
        function( "bar"   , &bar    , 
            List::create( _["x"] = 0.0 ), 
            "documentation for bar " ) ;
        function( "foo"   , &foo    , 
            List::create( _["x"] = 1, _["y"] = 1.0 ),
            "documentation for foo " ) ;        
        
        class_<World>( "World" )
        
            // expose the default constructor
            .constructor()    
            
                .method( "greet", &World::greet , "get the message" )
                .method( "set", &World::set     , "set the message" )
        ;
}

So, the idea is that one defines "normal" C++ functions and classes (I'm not sure if they satisfy some restriction) and then via RCPP_MODULE(yada){...} a new module called yada is created that "export" all the C++ functions and classes to R (so they can be accessed from R).
There remains the man directory, but I will not enter in details now. So, lets try to install the package. So I run in a linux console in the directory that contains the source package (that is, that contains the directory testmod) the following:

$ R CMD INSTALL testmod
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘testmod’ ...
** libs
g++ -I/usr/share/R/include   -I"/usr/local/lib/R/site-library/Rcpp/include"   -fpic  -O3 -pipe  -g -c rcpp_hello_world.cpp -o rcpp_hello_world.o
g++ -I/usr/share/R/include   -I"/usr/local/lib/R/site-library/Rcpp/include"   -fpic  -O3 -pipe  -g -c rcpp_module.cpp -o rcpp_module.o
g++ -shared -o testmod.so rcpp_hello_world.o rcpp_module.o -L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib -L/usr/lib64/R/lib -lR
installing to /home/juan/R/x86_64-pc-linux-gnu-library/2.12/testmod/libs
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/testmod/man/testmod-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/testmod/man/testmod-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘testmod’
    finding HTML links ... done
    rcpp_hello_world                        html  
    testmod-package                         html  
    yada                                    html  
** building package indices ...
** testing if installed package can be loaded

* DONE (testmod)

so it seems to work. Now lets run a R console and look if the package is accessible:

> require("testmod")
Loading required package: testmod
Loading required package: Rcpp

so it seems that the package was loaded. Now lets try something with it (I pick what to do looking inside src/rcpp_module.cpp and in the Rccp module vignettes). I first try:

> require("testmod")
Loading required package: testmod
Loading required package: Rcpp
> yada$hello()
terminate called after throwing an instance of 'std::range_error'
  what():  boom
Aborted
$

so it displays "boom" and then aborted returning to the linux console as expected, that is, it works. Now lets try:

> require("testmod")
Loading required package: testmod
Loading required package: Rcpp
> yada$bar(2)
[1] 4
> yada$foo(1L,0.8)
[1] 0.8
> yada$bla()
hello
> yada$bla1(10)
hello (x = 10)
> yada$bla2(10L,0.5)
hello (x = 10, y =  0.50)
> a <- new( yada$World )
> a
C++ object <0x136f5e0> of class 'World' <0x181ae50>
> a$greet()
[1] "hello"
> a$set("mama")
> a$greet()
[1] "mama"

So, it works (even the class) !!!. Now, what about zzz.R ? I assumes that when the package is required the code inside zzz.R is "loaded" and "executed" as was done with all the .R files in the R directory as is determined in the NAMESPACE file.

TODO: Now it is time to experiment with code of my own (starting by modifications of these packages) and to explore the possibility of the inclusion of the Lemon Graph Library.
Salut !

R Learning - Building R packages that integrates C++ via Rcpp - n.2

2011-02-09T20:46:00.009-03:00

In a previous post I wrote a kind of logbook about my first package building. It was so naive, but it was very useful also because it gives to me very important basic notions.

Exploring with my first package was good, but it does not integrate C++ code. So in this post my intention will be to build my first packages that integrates C++ code via Rcpp. In fact I'm planning a series of post (that start with the previous one mentioned above). In this post I will explore the option provided by the function Rccp.package.skeleton() provided in the Rcpp package. More precisely, this function provides two basic options to explore. The first one just build a "plain" Rcpp based package, and the second one a Rcpp package based on the usage of Rcpp modules. So here I will explore the first of these two options. Next the second option, and finally an important option. One that integrates the Lemon Graph Library (see here).

I will follow (as a first guide) this: Writing a package that uses Rcpp - Dirk Eddelbuettel
, mixed with the basic help provided by:

> ?Rcpp.package.skeleton

So, the first thing is typing in a R console:

> require("Rcpp")
Loading required package: Rcpp
> Rcpp.package.skeleton( "foobar" )
Creating directories ...
Creating DESCRIPTION ...
Creating NAMESPACE ...
Creating Read-and-delete-me ...
Saving functions and data ...
Making help files ...
Done.
Further steps are described in './foobar/Read-and-delete-me'.

Adding Rcpp settings
 >> added Depends: Rcpp
 >> added LinkingTo: Rcpp
 >> added useDynLib directive to NAMESPACE
 >> added Makevars file with Rcpp settings
 >> added Makevars.win file with Rcpp settings
 >> added example header file using Rcpp classes
 >> added example src file using Rcpp classes
 >> added example R file calling the C++ example
 >> added Rd file for rcpp_hello_world

Now in the directory from where I run the R console a new directory called foobar appears. Inside it is the following (3 subdirectories and 3 files):

$ ls
DESCRIPTION  man  NAMESPACE  R  Read-and-delete-me  src

Inside DESCRIPTION the following appears:

Package: foobar
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-09
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What Licence is it under ?
LazyLoad: yes
Depends: Rcpp (>= 0.9.0)
LinkingTo: Rcpp

I think that R uses in some way the information inside DESCRIPTION but for the moment I will not discuss in detail what it means because I believe that the package can be installed without pay to much attention to this. Inside NAMESPACE the following appears:

useDynLib(foobar)
exportPattern("^[[:alpha:]]+")

This require some explanation. What this mean? Something is explained here: Writing R extensions - packages and namespaces. I will not (at least for the moment) enter in details, but it allows the package writer to specify which variables in the package should be exported to make them available to package users, and which variables should be imported from other packages. As stated here the first line ensure that the dynamic library contained in the package that have been cre-ated via Rcpp.package.skeleton will be loaded and thereby made available to the newly created R package. The second line declares which functions should be globally visible from the namespace of this package, in this case (as reasonable default) it export all functions.

Then, Inside Read-and-delete-me says:

* Edit the help file skeletons in 'man', possibly combining help files
  for multiple functions.
* Edit the exports in 'NAMESPACE', and add necessary imports.
* Put any C/C++/Fortran code in 'src'.
* If you have compiled code, add a useDynLib() directive to
  'NAMESPACE'.
* Run R CMD build to build the package tarball.
* Run R CMD check to check the package tarball.

Read "Writing R Extensions" for more information.

which essentially does not differ from the one obtained when building a common package (look here). Now is time to look inside the directories. Inside the R directory there is a fille called rcpp_hello_world.R. Inside it one can find:

rcpp_hello_world <- function(){
        .Call( "rcpp_hello_world", PACKAGE = "foobar" )
}

So, it is just a R function definition in whose body it calls an external C++ function via the .Call() R function. For the moment, there is no to much to say about this. Then I look inside the src directory and found 4 files:

$ ls
Makevars  Makevars.win  rcpp_hello_world.cpp  rcpp_hello_world.h

Inside rcpp_hello_world.h one finds:

#ifndef _foobar_RCPP_HELLO_WORLD_H
#define _foobar_RCPP_HELLO_WORLD_H

#include <Rcpp.h>

/*
 * note : RcppExport is an alias to `extern "C"` defined by Rcpp.
 *
 * It gives C calling convention to the rcpp_hello_world function so that 
 * it can be called from .Call in R. Otherwise, the C++ compiler mangles the 
 * name of the function and .Call can't find it.
 *
 * It is only useful to use RcppExport when the function is intended to be called
 * by .Call. See the thread http://thread.gmane.org/gmane.comp.lang.r.rcpp/649/focus=672
 * on Rcpp-devel for a misuse of RcppExport
 */
RcppExport SEXP rcpp_hello_world() ;

#endif

so, it is a "standard" .h file which includes the Rcpp.h file and declared the C++ function rcpp_hello_world(). Inside the rcpp_hello_world.cpp file one finds:

#include "rcpp_hello_world.h"

SEXP rcpp_hello_world(){
    using namespace Rcpp ;
    
    CharacterVector x = CharacterVector::create( "foo", "bar" )  ;
    NumericVector y   = NumericVector::create( 0.0, 1.0 ) ;
    List z            = List::create( x, y ) ;
    
    return z ;
}

So, it includes the previous .h header, and defines the rcpp_hello_world() function. Note here that in the declaration the function name is preceded by RcppExport and in the definition it is preceded by SEXP. It seems (as commented in the header) that RcppExport also "extern" to C code the C++ code (plus setting the returning type to SEXP).

Now, here comes the most involved part here (what to put inside the .cpp and .h files is more related to programming, but not to packaging). Inside Makevars there one can see:

## Use the R_HOME indirection to support installations of multiple R version
PKG_LIBS = `$(R_HOME)/bin/Rscript -e "Rcpp:::LdFlags()"`

## As an alternative, one can also add this code in a file 'configure'
##
##    PKG_LIBS=`${R_HOME}/bin/Rscript -e "Rcpp:::LdFlags()"`
## 
##    sed -e "s|@PKG_LIBS@|${PKG_LIBS}|" \
##        src/Makevars.in > src/Makevars
## 
## which together with the following file 'src/Makevars.in'
##
##    PKG_LIBS = @PKG_LIBS@
##
## can be used to create src/Makevars dynamically. This scheme is more
## powerful and can be expanded to also check for and link with other
## libraries.  It should be complemented by a file 'cleanup'
##
##    rm src/Makevars
##
## which removes the autogenerated file src/Makevars. 
##
## Of course, autoconf can also be used to write configure files. This is
## done by a number of packages, but recommended only for more advanced users
## comfortable with autoconf and its related tools.

So it seems that this has to do with linking during C++ compilation time. As stated in Writing a package that uses Rcpp - Dirk Eddelbuettel it seems that R does not provide an self-enough (C++) library linking mechanism this must be done "manually". Obviously this (probably) will be a main matter in the case of including the Lemong Graph Library (se here) to the Rcpp code here.

The remaining file Makevars.win is the windows version of this one (so, for the moment I'm not interested in it).

Finally, inside the man directory there are 2 files:

ls
foobar-package.Rd  rcpp_hello_world.Rd

I will not enter in detail about the man directory (unless I need to do it in order to install the package).

So, the next thing to do, is to install the package to see if it works. So in a linux console inside the directory that contains foobar I run:

$ R CMD INSTALL foobar
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘foobar’ ...
** libs
g++ -I/usr/share/R/include   -I"/usr/local/lib/R/site-library/Rcpp/include"   -fpic  -O3 -pipe  -g -c rcpp_hello_world.cpp -o rcpp_hello_world.o
g++ -shared -o foobar.so rcpp_hello_world.o -L/usr/local/lib/R/site-library/Rcpp/lib -lRcpp -Wl,-rpath,/usr/local/lib/R/site-library/Rcpp/lib -L/usr/lib64/R/lib -lR
installing to /home/juan/R/x86_64-pc-linux-gnu-library/2.12/foobar/libs
** R
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/foobar/man/foobar-package.Rd:32: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/foobar/man/foobar-package.Rd:33: All text must be in a section
*** installing help indices
  converting help for package ‘foobar’
    finding HTML links ... done
    foobar-package                          html  
    rcpp_hello_world                        html  
** building package indices ...
** testing if installed package can be loaded

* DONE (foobar)

So, it seems to work. Now lets see if its work, that is, if it can be loaded from R. So I open a R console and write:

> require("foobar")
Loading required package: foobar
Loading required package: Rcpp
> rcpp_hello_world()
[[1]]
[1] "foo" "bar"

[[2]]
[1] 0 1

So, it works !!!.
TODO: Now there remains two things. Explore the option/example that uses modules, andthen try to include the Lemon Graph Library.

Salut !

C++ Learning - General concepts, resources, tips, ...

2011-02-08T09:28:00.008-03:00

I know some about C++, but I need learn more.

Specifically about C++ (basic C++, standard libraries, etc):

This (C++ for C users) may be an adequate starting point.

Related to C++ (compilation, environment, etc):

Clearly there aare some issues about the configure, make, install, Makevars, etc., files commonly used when compiling and installing C++ code (into a linux system?) about which I know almost nothing. So this seems to be an inescapable topic that eventually I must to deal with. This list contain things that may help:

Using Automake and Autoconf with C++
Installing from tarballs

List of important concepts, tips to take in account:

1) Here is some important discussion about templates and typedef.

List of answered doubts:

1) I eventually found some C++ code like this:

int Loan::calcInterest() const
{
        return loan_value * interest_rate; 
}

What does the "const" means? Well, it means that function Loan::calcInterest() is (defined by the programmer) a safe function member to call from objects instantiated as const. In other words, if that const where not there, then the followingcode will return compilation error:

const Loan a(100);

a.calcInterest(); //Here error compilation

But the const token defines that this function can be safely called as a member function of a const object. Here more detailed explanation.

Salut !

R Learning - Building R packages n.1

2011-02-07T22:09:00.024-03:00

In previous posts (for example this and this) I state about my necessity to integrate C++ code (that makes use of C++ libraries) into R.

I'm not sure if using the inline package is enough. In fact, I begin to believe that using inline brings out the problem of sharing functions between different .cpp modules. I don't know if it is possbile.

So, it seems that the solution is to build an R package. This (series of) post is dedicated to learn to build R packages that integrates Rcpp code.
Obviously, the main resource is:

Writing R Extensions

But this .pdf Creating R Packages: A Tutorial - Friedrich Leisch is a convenient starting point.

Specifically in relation to Rcpp there exist Rcpp.package.skeleton which is the Rcpp version of package.skeleton

So, lets start from something easy. I open an R console and write:

> ?package.skeleton

and I obtaing a realtively long description about this R function. In there it gives this example:

> require(stats)
> ## two functions and two "data sets" :
> f <- function(x,y) x+y
> g <- function(x,y) x-y
> d <- data.frame(a=1, b=2)
> e <- rnorm(1000)
> package.skeleton(list=c("f","g","d","e"), name="mypkg")

Lets see what it does. I executed this code in the R console and then look inside the directory from where I run the R console. I found inside there a directory called mypkg. Inside mypkg there are 3 more directories: data, man, R and 2 files: DESCRIPTION and Read-and-delete-me. Inside DESCRIPTION it says:

Package: mypkg
Type: Package
Title: What the package does (short line)
Version: 1.0
Date: 2011-02-09
Author: Who wrote it
Maintainer: Who to complain to <yourfault@somewhere.net>
Description: More about what it does (maybe more than one line)
License: What license is it under?
LazyLoad: yes

so this is information about the package. Inside Read-and-delete-me it says:

* Edit the help file skeletons in 'man', possibly combining help files
  for multiple functions.
* Put any C/C++/Fortran code in 'src'.
* If you have compiled code, add a .First.lib() function in 'R' to load
  the shared object.
* Run R CMD build to build the package tarball.
* Run R CMD check to check the package tarball.

Read "Writing R Extensions" for more information.

So it gives information very basic instructions of the following steps to do. The I look inside the directories. First I look inside R and found two files: f.R and g.R (the two functions passed to package.skeleton()). So I look inside them and found:

#the f.R file...
f <-
function(x,y) x+y
#the g.R file...
g <-
function(x,y) x-y

so, there are just the function declarations. Then I look inside the DATA directory and found 2 files: d.rda and e.rda. When I try to look inside them (using the less linix command) it accuse me that they are binary files. So I assume that those files contains the data objects passed to the package.skeleton() function. Finally I look inside the man directory
and found 5 files: d.Rd, e.Rd, f.Rd, g.Rd and mypkg-package.Rd. I look inside 3 of them and found. For d.Rd:

\name{d}
\alias{d}
\docType{data}
\title{
%%   ~~ data name/kind ... ~~
}
\description{
%%  ~~ A concise (1-5 lines) description of the dataset. ~~
}
\usage{data(d)}
\format{
  A data frame with 1 observations on the following 2 variables.
  \describe{
    \item{\code{a}}{a numeric vector}
    \item{\code{b}}{a numeric vector}
  }
}
\details{
%%  ~~ If necessary, more details than the __description__ above ~~
}
\source{
%%  ~~ reference to a publication or URL from which the data were obtained ~~
}
\references{
%%  ~~ possibly secondary sources and usages ~~
}
\examples{
data(d)
## maybe str(d) ; plot(d) ...
}
\keyword{datasets}

for f.Rd:

\name{f}
\alias{f}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
%%  ~~function to do ... ~~
}
\description{
%%  ~~ A concise (1-5 lines) description of what the function does. ~~
}
\usage{
f(x, y)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
  \item{x}{
%%     ~~Describe \code{x} here~~
}
  \item{y}{
%%     ~~Describe \code{y} here~~
}
}
\details{
%%  ~~ If necessary, more details than the description above ~~
}
\value{
%%  ~Describe the value returned
%%  If it is a LIST, use
%%  \item{comp1 }{Description of 'comp1'}
%%  \item{comp2 }{Description of 'comp2'}
%% ...
}
\references{
%% ~put references to the literature/web site here ~
}
\author{
%%  ~~who you are~~
}
\note{
%%  ~~further notes~~
}

%% ~Make other sections like Warning with \section{Warning }{....} ~

\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
}
\examples{
##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--    or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function(x,y) x+y
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line

and for mypkg-package.Rd:

\name{mypkg-package}
\alias{mypkg-package}
\alias{mypkg}
\docType{package}
\title{
What the package does (short line)
~~ package title ~~
}
\description{
More about what it does (maybe more than one line)
~~ A concise (1-5 lines) description of the package ~~
}
\details{
\tabular{ll}{
Package: \tab mypkg\cr
Type: \tab Package\cr
Version: \tab 1.0\cr
Date: \tab 2011-02-09\cr
License: \tab What license is it under?\cr
LazyLoad: \tab yes\cr
}
~~ An overview of how to use the package, including the most important ~~
~~ functions ~~
}
\author{
Who wrote it

Maintainer: Who to complain to <yourfault@somewhere.net>
~~ The author and/or maintainer of the package ~~
}
\references{
~~ Literature or other references for background information ~~
}
~~ Optionally other standard keywords, one per line, from file KEYWORDS in ~~
~~ the R documentation directory ~~
\keyword{ package }
\seealso{
~~ Optional links to other man pages, e.g. ~~
~~ \code{\link[<pkg>:<pkg>-package]{<pkg>}} ~~
}
\examples{
~~ simple examples of the most important functions ~~
}

So, this correspond to the "descrpition"/"help"/"man" files of the R objects stored in the package and also a "description"/"help"/"man" file of the R package itself.

Now I'm not sure how what is the right next thing to do. Reading the .pdf above (Creating R Packages: A Tutorial - Friedrich Leisch) it "talks" about 3 commands (executed in a linux terminal on the directory that contains the packages directory, i.e., in this case the directory that contains the directory pkgname) that can be done over a package. These are the following ones:

First (maybe with another command options not stated on this examples):

$ R CMD INSTALL pkgname

this installs the package into a library and makes it available for usage in R. Second:

$ R CMD check pkgname

runs a battery of tests on the package. Third:

$ R CMD build pkgname

removes temporary files from the source tree of the package and packs everything into anarchive file.
Now before keep going it is convenient to incorporate some specific terms (I stole them from the previously mentionated .pdf) :

Package: An extension of the R base system with code, data and documentation in standardized format.
Library: A directory containing installed packages.
Repository: A website providing packages for installation.
Source: The original version of a package with human-readable text and code.
Binary: A compiled version of a package with computer-readable text and code, may work only on a specific platform.
Base packages: Part of the R source tree, maintained by R Core.
Recommended packages: Part of every R installation, but not necessarily maintained by R Core.
Contributed packages: All the rest. This does not mean that these packages are necessarily of lesser quality than the above, e.g., many contributed packages on CRAN are written and maintained by R Core members. We simply try to keep the base distribution as lean as possible.

Now I guess that the following step to do is to run R CMD INSTALL. I believe that this is the standard way of "test" (or maybe "debug") a package (installing it, and then requiring it from a R console, and playing with the package content). Anyway, it happens that in principle one must specify the path to the library where the package will be installed.

In a R console I get:

> .libPaths()
[1] "/home/juan/R/x86_64-pc-linux-gnu-library/2.12"
[2] "/usr/local/lib/R/site-library"                
[3] "/usr/lib/R/site-library"                      
[4] "/usr/lib/R/library"                           
[5] "/usr/lib64/R/library"

So, those are the R libraries that my system has. The first of them has:

juan@juanlaptop:~/R/x86_64-pc-linux-gnu-library/2.12$ ls
RcppArmadillo  RcppClassic  RcppExamples  R.css

So it seems that here are contributed packages (all of them related to Rcpp). The second of them has:

juan@juanlaptop:/usr/local/lib/R/site-library$ ls
doMC  foreach  igraph  inline  multicore  network  Rcpp  R.css

that also are contributed packages. The third of them has:

juan@juanlaptop:/usr/lib/R/site-library$ ls
doMC  doSNOW  foreach  iterators  jit  multicore  Rcpp  R.css  Revobase

Note that some packages in the second and the third are repeated. I think that this has to do with the fact that I reinstalled R in order to update my R version (look this previouspost). In fact, Rcpp in the second library is version (as I can deduce looking inside the DESCRIPTION file in the Rcpp directory) 0.9.0, meanwhile Rcpp in the third library is version 0.6.5, so the R packages of the old installation is in the third library.
The fourth library looks:

juan@juanlaptop:/usr/lib/R/library$ ls
abind      class      cubature   Ecdat    Formula    grid        lattice  mgcv        nlme      quadprog  scatterplot3d  SparseM  stats     timeDate  utils
base       cluster    datasets   ellipse  gclus      gtools      MASS     miscTools   nnet      R.css     slam           spatial  stats4    tools     xtable
bdsmatrix  coda       degreenet  ergm     graphics   ineq        Matrix   modeltools  numDeriv  rlecuyer  sna            splines  survival  trust
boot       codetools  e1071      foreign  grDevices  KernSmooth  methods  mvtnorm     nws       rpart     snow           statmod  tcltk     urca

and the fifth looks:

juan@juanlaptop:/usr/lib64/R/library$ ls
abind      class      cubature   Ecdat    Formula    grid        lattice  mgcv        nlme      quadprog  scatterplot3d  SparseM  stats     timeDate  utils
base       cluster    datasets   ellipse  gclus      gtools      MASS     miscTools   nnet      R.css     slam           spatial  stats4    tools     xtable
bdsmatrix  coda       degreenet  ergm     graphics   ineq        Matrix   modeltools  numDeriv  rlecuyer  sna            splines  survival  trust
boot       codetools  e1071      foreign  grDevices  KernSmooth  methods  mvtnorm     nws       rpart     snow           statmod  tcltk     urca

So, both are base R libraries, the difference being the 32 or 64 bit platform. Looking inside the DESCRIPTION file in the base directory (in both libraries), versions are the same with value 2.12.1 (so they are the last I install).

Now, where is the right place to install my packages? I think that the first one is the best choice. It is inside my home so it cannot destroy the R core system, also it does not require linux root access (I think the other libraries does). Also is the first on the list, so is the default one (in principle).

Lets try to see what happens.
So in a linux console, inside the container directory of mypkg source package directory (mypkg is the source that I construct as mentioned above using package.skeleton()) I get:

$ R CMD INSTALL mypkg/
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘mypkg’ ...
** R
** data
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:34: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:35: All text must be in a section
*** installing help indices
Error in Rd_info(db[[i]]) : 
  Rd files must have a non-empty \title.
See chapter 'Writing R documentation' in manual 'Writing R Extensions'.
* removing ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12/mypkg’

So, it fails because "Rd files must have a non-empty \title.". Note also that as I speculated above it try to install the package in the first library as it can be deduced from the last line. Lets try to "solve" the error in order the installation goes right.

So, I add some titles (and things like that) to the .Rd files inside ../mypkg/man/ and then I try again to install the package and I get:


$ R CMD INSTALL mypkg/
* installing to library ‘/home/juan/R/x86_64-pc-linux-gnu-library/2.12’
* installing *source* package ‘mypkg’ ...
** R
** data
** preparing package for lazy loading
** help
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:34: All text must be in a section
Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:35: All text must be in a section
*** installing help indices
  converting help for package ‘mypkg’
    finding HTML links ... done
    d                                       html  
    e                                       html  
    f                                       html  
    g                                       html  
    mypkg-package                           html  
** building package indices ...
** testing if installed package can be loaded

* DONE (mypkg)

So, it seems to work. Lets see if I call require it from a R console:

> require("mypkg")
Loading required package: mypkg
> data(d)
> data(e)
> f(1,2)
[1] 3
> g(1,2)
[1] -1
> d
  a b
1 1 1
> e
   [1] -0.733391210  1.035536205 -0.297609744 -0.340793522  1.529938790
   [6]  0.860719209  1.528990851 -0.593957432 -0.876811563  0.083046158
 ... BLA BLA BLA ...

So, it works nice !!! Also if I type:

> ?g

I get:

g                    package:mypkg                     R Documentation

Function that returns the substraction of two numeric arguments.

Description:

     A second very simple function.

Usage:

     g(x, y)
     
Arguments:

       x:

       y:

Examples:

     ##---- Should be DIRECTLY executable !! ----
     ##-- ==>  Define data, use random,
     ##--    or do  help(data=index)  for the standard data sets.
     
     ## The function is currently defined as
     function(x,y) x-y

That is, I also get the R help inside "man" of the mypkg package. Now lets try check. In the container directory of mypkg I get:

$ R CMD INSTALL mypkg/
 ... BLA BLA BLA ...
Error: parse error in file 'mypkg-Ex.R':
11: unexpected symbol
99: 
100: ~~ simple examples
               ^
Execution halted
* checking data for non-ASCII characters ... OK
* checking examples ... ERROR
Running examples in ‘mypkg-Ex.R’ failed
The error most likely occurred in:

> ### Name: mypkg-package
> ### Title: What the package does (short line) ~~ package title ~~
> ### Aliases: mypkg-package mypkg
> ### Keywords: package
> 
> ### ** Examples
> 
> ~~ simple examples of the most important functions ~~
Error: unexpected symbol in "~~ simple examples"
Execution halted

So the checking fails for a problem with the examples. Then I corrected those errors and finally checked with 4 Warnings (that can be found inside ):

* checking whether package ‘mypkg’ can be installed ... WARNING
Found the following significant warnings:
  Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:34: All text must be in a section
  Warning: /home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg/man/mypkg-package.Rd:35: All text must be in a section
See ‘/home/juan/Desktop/facu/investigacion_ensayos/Cosas_crudas/programming_coding/R-work-space/integrating_R_with_cpp_via_Rcpp/using_packages/mypkg.Rcheck/00install.out’ for details.
... BLA BLA BLA ...
* checking DESCRIPTION meta-information ... WARNING
Non-standard license specification:
  What license is it under?
Standardizable: FALSE

So, it remains TODO a build... but it is not interesting to build this package. The most interesting thing to do is to explore with a package that involves the usage of Rcpp.

TODO : Make an experiment with a package that involves the usage of Rcpp.

Salut !

Resources - Mailing Lists, Forums, and so like

2011-02-07T11:13:00.011-03:00

I have started to deal with mailing list (as a consequence of R, Rcpp, BGL, LGL and igraph). It is an important resource in order to get out of trouble.

So I list here the list of mailing list, forums, and so on:

1) Miscelaneous (I put here things that I don't know how to classify yet):

http://stackoverflow.com/
http://meta.stackoverflow.com/

2) Mailing lists:

List of R mailing lists
rcpp-develop mailing list
R-sig-networks (graph-network R mailing list)
R-sig-hpc -- High-Performance Computing with R
roxygen mailing list
Non R...
igraph mailing list
Lemon Graph Library (user level) mailing list
codelite user mailing list
Boost C++ User mailing list

3) Forums:

Codelite forum

Salut !

Lemon Graph Library (LGL) instalation - logbook

2011-02-05T10:57:00.019-03:00

In a previous post I wrote about a library dedicated to work with graph. It is called Lemon Graph Library (LGL). The idea is eventually integrate LGL with R via Rcpp. So it seems that I first need to install the LGL.

Why to install LGL instead of simply use its .cc and .h files? Well, I look inside the .cc and .h files and the inclusion of other .h headers goes like this:

#include<lemon/tolerance.h>
#include<lemon/core.h>

(I pick this lines from ../lemon/base.cc). So it seems that in order that the inclusion of the headers can be donde, then the library needs to be installed.

So, in this post I will write the logbook about the installation of LGL.
I will follow this instructions.

I had downloaded lemon-1.2.1.tar.gz and untared it. Now I'm in a ubuntu console inside the lemon-1.2.1 directory. I then proceed:

../lemon-1.2.1$ ./configure

and seems to work. Now I proceed:

../lemon-1.2.1$ make

and also seems to work. Now I proceed:

../lemon-1.2.1$ make check

and I get this:

test/test_tools_fail.cc:23: error: Don't panic. Failing is the right behaviour here.
/bin/bash: line 5:  7977 Aborted                 ${dir}$tst
XFAIL: test/test_tools_fail
PASS: test/test_tools_pass
u: 0.07s, s: 0.03s, cu: 0s, cs: 0s, real: 0.100001s (77313 time queries)
u: 3.27826e-09s, s: 0s, cu: 0s, cs: 0s, real: 3.12811e-09s (33554432 tests)
Total: u: 0.11s, s: 0s, cu: 0s, cs: 0s, real: 0.104962s
u: 0.000859375s, s: 0.0003125s, cu: 0s, cs: 0s, real: 0.00124676s (128 tests)
Total: u: 0.11s, s: 0.04s, cu: 0s, cs: 0s, real: 0.159585s
PASS: test/time_measure_test
PASS: test/unionfind_test
=====================================================
All 36 tests behaved as expected (1 expected failure)
=====================================================

It seems that there is a failure, but this failure is intentional. So, it also seems to work. Now I proceed:

../lemon-1.2.1$ sudo make install

and it seems to work (note that I used sudo (root permissions), so I installed the library in the standard directory) and I get this (Note that in the blog the vertical pipe character may not appear. I put all this here because I want to have a register about what happens):

test -z "/usr/local/lib" || /bin/mkdir -p "/usr/local/lib"
 /bin/bash ./libtool   --mode=install /usr/bin/install -c   lemon/libemon.la '/usr/local/lib'
libtool: install: /usr/bin/install -c lemon/.libs/libemon.lai /usr/local/lib/libemon.la
libtool: install: /usr/bin/install -c lemon/.libs/libemon.a /usr/local/lib/libemon.a
libtool: install: chmod 644 /usr/local/lib/libemon.a
libtool: install: ranlib /usr/local/lib/libemon.a
libtool: finish: PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/X11R6/bin:/sbin" ldconfig -n /usr/local/lib
----------------------------------------------------------------------
Libraries have been installed in:
   /usr/local/lib

If you ever happen to want to link against installed libraries
in a given directory, LIBDIR, you must either use libtool, and
specify the full pathname of the library, or use the `-LLIBDIR'
flag during linking and do at least one of the following:
   - add LIBDIR to the `LD_LIBRARY_PATH' environment variable
     during execution
   - add LIBDIR to the `LD_RUN_PATH' environment variable
     during linking
   - use the `-Wl,-rpath -Wl,LIBDIR' linker flag
   - have your system administrator add LIBDIR to `/etc/ld.so.conf'

See any operating system documentation about shared libraries for
more information, such as the ld(1) and ld.so(8) manual pages.
----------------------------------------------------------------------
test -z "/usr/local/bin" || /bin/mkdir -p "/usr/local/bin"
  /bin/bash ./libtool   --mode=install /usr/bin/install -c tools/dimacs-solver tools/dimacs-to-lgf tools/lgf-gen '/usr/local/bin'
libtool: install: /usr/bin/install -c tools/dimacs-solver /usr/local/bin/dimacs-solver
libtool: install: /usr/bin/install -c tools/dimacs-to-lgf /usr/local/bin/dimacs-to-lgf
libtool: install: /usr/bin/install -c tools/lgf-gen /usr/local/bin/lgf-gen
test -z "/usr/local/bin" || /bin/mkdir -p "/usr/local/bin"
 /usr/bin/install -c tools/lemon-0.x-to-1.x.sh '/usr/local/bin'
test -z "/usr/local/include/lemon/bits" || /bin/mkdir -p "/usr/local/include/lemon/bits"
 /usr/bin/install -c -m 644 lemon/bits/alteration_notifier.h lemon/bits/array_map.h lemon/bits/bezier.h lemon/bits/default_map.h lemon/bits/edge_set_extender.h lemon/bits/enable_if.h lemon/bits/graph_adaptor_extender.h lemon/bits/graph_extender.h lemon/bits/map_extender.h lemon/bits/path_dump.h lemon/bits/solver_bits.h lemon/bits/traits.h lemon/bits/variant.h lemon/bits/vector_map.h '/usr/local/include/lemon/bits'
test -z "/usr/local/include/lemon/concepts" || /bin/mkdir -p "/usr/local/include/lemon/concepts"
 /usr/bin/install -c -m 644 lemon/concepts/digraph.h lemon/concepts/graph.h lemon/concepts/graph_components.h lemon/concepts/heap.h lemon/concepts/maps.h lemon/concepts/path.h '/usr/local/include/lemon/concepts'
test -z "/usr/local/include/lemon" || /bin/mkdir -p "/usr/local/include/lemon"
 /usr/bin/install -c -m 644 lemon/adaptors.h lemon/arg_parser.h lemon/assert.h lemon/bellman_ford.h lemon/bfs.h lemon/bin_heap.h lemon/binomial_heap.h lemon/bucket_heap.h lemon/capacity_scaling.h lemon/cbc.h lemon/circulation.h lemon/clp.h lemon/color.h lemon/concept_check.h lemon/connectivity.h lemon/core.h lemon/cost_scaling.h lemon/counter.h lemon/cplex.h lemon/cycle_canceling.h lemon/dfs.h lemon/dheap.h lemon/dijkstra.h lemon/dim2.h lemon/dimacs.h lemon/edge_set.h lemon/elevator.h lemon/error.h lemon/euler.h lemon/fib_heap.h lemon/fractional_matching.h lemon/full_graph.h lemon/glpk.h lemon/gomory_hu.h lemon/graph_to_eps.h lemon/grid_graph.h lemon/hartmann_orlin_mmc.h lemon/howard_mmc.h lemon/hypercube_graph.h lemon/karp_mmc.h '/usr/local/include/lemon'
 /usr/bin/install -c -m 644 lemon/kruskal.h lemon/hao_orlin.h lemon/lgf_reader.h lemon/lgf_writer.h lemon/list_graph.h lemon/lp.h lemon/lp_base.h lemon/lp_skeleton.h lemon/maps.h lemon/matching.h lemon/math.h lemon/min_cost_arborescence.h lemon/nauty_reader.h lemon/network_simplex.h lemon/pairing_heap.h lemon/path.h lemon/planarity.h lemon/preflow.h lemon/quad_heap.h lemon/radix_heap.h lemon/radix_sort.h lemon/random.h lemon/smart_graph.h lemon/soplex.h lemon/static_graph.h lemon/suurballe.h lemon/time_measure.h lemon/tolerance.h lemon/unionfind.h lemon/bits/windows.h '/usr/local/include/lemon'
test -z "/usr/local/include/lemon" || /bin/mkdir -p "/usr/local/include/lemon"
 /usr/bin/install -c -m 644 lemon/config.h '/usr/local/include/lemon'
test -z "/usr/local/lib/pkgconfig" || /bin/mkdir -p "/usr/local/lib/pkgconfig"
 /usr/bin/install -c -m 644 lemon/lemon.pc '/usr/local/lib/pkgconfig'

Now is time to make a simple test to see if I can use the library (for the moment in the standard way, not including it in R). I will try what is written here which says:

$g++ -O2 mycode.cc -lemon

But for that, I need a mycode.cc example, so I will try this one (obtained from here):

#include <iostream>
#include <lemon/list_graph.h>

using namespace lemon;
using namespace std;

int main()
{
  ListDigraph g;

  ListDigraph::Node u = g.addNode();
  ListDigraph::Node v = g.addNode();
  ListDigraph::Arc  a = g.addArc(u, v);

  cout << "Hello World! This is LEMON library here." << endl;
  cout << "We have a directed graph with " << countNodes(g) << " nodes "
       << "and " << countArcs(g) << " arc." << endl;

  return 0;
}

It works as can be seen from what I had obtained:

$./a.out
Hello World! This is LEMON library here.
We have a directed graph with 2 nodes and 1 arc.

Now I have to try to integrate Lemon to R via Rcpp. So I write a file called myexample_inline.R with this content:

 inc <- '
        #include <lemon/list_graph.h>
        using namespace lemon ;
        '
 
 src <- '
        int xx = Rcpp::as<int>(x);

        int res = xx + 1;

        ListDigraph g;

        ListDigraph::Node u = g.addNode();
        ListDigraph::Node v = g.addNode();
        ListDigraph::Arc  a = g.addArc(u, v);

        int i = countNodes(g);
        int j = countArcs(g);

        Rprintf("num nodes is %d , and num edges is %d \\n",i,j);

        return Rcpp::wrap(res);
        '

 fun <- cxxfunction( signature(x="numeric"), body=src,include=inc, plugin="Rcpp")

Then I run R from a ubuntu terminal and in the R console I obtain:


> library("inline")
> library("Rcpp")
> source("myexample_inline.R")
> fun(1)
num nodes is 2 , and num edges is 1 
[1] 2

So it works !!!

TODO: What if I want to construct a package that uses LGL. How I do that? The right thing is that the installation of a R package can not depend on the installation of another non R package as LGL. So this is something that I need to explore.

TODO: Now I have a question. In the example the C++ function is "inlined" in R. So, if I want to call that function from other C++ function: How I do it? And if it is possible: It is (in terms of speed) convenient?
Maybe "inlining" is not the best choice. What other options do I have? Maybe this (and this) may be helpful.
Also I open this question in http://stackoverflow.com/, so maybe I get some answer from there.
This is the rcpp-development list which I have subscribed to.

Salut !

R, Rcpp, and the Lemon Graph Library (LGL) and others options

2011-02-04T10:34:00.009-03:00

In a previous post it wrote about the possibility to combine BGL with Rcpp (I also discuss other options). I do not read to much about BGL, so I do not know if it is a nice option.

Here I found that along with BGL there are other options. In this post I want to write about the Lemon Graph Library (LGL). This seems a very nice option to work with graph (as I can see reading a little inside the its home page). The only thing that I don't know if it is easily integrable with Rcpp.
It seems that it uses STL, but it is not entirely developed trough the use of it. That is the reason that make me suspicious about its integrability with Rcpp.

LGL is integrable to R with Rcpp. At least using the inline package. Check this posts.

TODO: Is convenient to integrate LGL to R using the inline package?
TODO: Is LGL integrable as an R package?

Divergent discussion:

Here it is a post which discuss several options and talks good about LGL.

Here a list of other options aside of LGL:

GOBLIN

Salut !

R, Rcpp, STL, Boost C++ Library and the Boost Graph Library inside it.

2011-02-03T20:44:00.009-03:00

In previous posts (this and this) I wrote about some of the benefits of Rcpp as an alternative to high performance computing in R.

Rcpp facilitates integrating C++ code and R code in severals ways. One of them are provided by Rcpp::as and Rcpp::wrap. But what are they?

a) Esencially Rcpp::wrap allows conversion of some C++ objects to R objects.
b) Vice-versa Rcpp::as allows conversion of R objects to C++ objects.

Obviously not every C++ object can be converted into an R object by means of Rcpp::wrap (so it seems that it can be programmed if necessary (and possible) by means of Rcpp-extending). Esentially one can convert:

i) primitive types: int, double, ...
ii) std::string objects
iii) STL containers such as std::vector<T>, std::list<T>,... as long as type T is also wrappeable.
iv) STL maps which use sdt::string for keys (e.g. std::map<std::string,T> as long as T is also wrappeable.v) any type that can be readily converted by means of SEXP()
vi) any type for which the wrap is fully specialized.

Something similar occurs with Rcpp::as (look here for more details). But what is STL? STL is the short of Standard Template Library which is related to the C++ Standard Library. STL provides important facilities as std::vectors, std::lists, std::deque and so on.

One of the interesting things related to it is the Boost C++ Libraries which is some kind of extension of the STL and C++ Standard Libraries. They are free, and in particular there is one that seems interesting to me. It is called Boost Graph Library (or BGL, developed by Jeremy Siek and a University of Notre Dame team). The home page of the Boost C++ Libraries seems to be this. In particular there is a section dedicated to the BGL one (is this). It seems that the Boost C++ Libraries can be downloaded from here. Interestingly there is also a Parallel BGL (which is based in BGL but redeveloped for parallel computation).

So, in another previous post (this) I analyzed the idea to integrate the igraph library with Rcpp. But maybe it will be easier trough the BGL library inside the Boost C++ Libraries because this last one is developed using STL. It is something that need to be explored with more care.

Note that BGL is already implemented in R (this is the link to the package)

TODO : look the BGL library inside the Boost C++ Libraries.Then try to determine if it is easily integrable with Rcpp.

In fact I made a list before about the different packages to handle graphs in R (this post). From that list now, I will remark the following ones:

igraph
RBGL
as the main options, but there are also:
graph
gRbase
giRaph

TODO: Check which of those alternatives are integrable with Rcpp.

Salut !

Idea: igraph on R intermediated by Rcpp

2011-02-02T14:21:00.003-03:00

The other day I found this (a slides from Roman Francois, one of the developers of Rcpp). There he shows that the speed difference between R and Rcpp can be very significant. Also, Rcpp provides facilities like Rcpp syntactic sugar and Rcpp modules which makes easier the integration with R and also facilitates the C++ code development (for example providing access to R functions and convenient Rcpp classes).

In the other hand, I'm probably focusing on Complex Networks research, so packages like igraph are very convenient. But, it is fast? I think that it may be reasonably fast. But, it is also fast in R? I'm not so sure about that. But, do not despair so fast, igraph is mainly coded in C, so one (as a last resource) can use those C routines to work with graph. But, hey !!! What happens with R? Well, looking inside the igraph R package one can see that there is used those C functions called by the R API. More specifically, the igraph R packages is constituted by:

(i)the standard igraph C code
(ii) a bit of R code (the wrapper R functions)
(iii) and another bit of C code that serves as interface between the R code and the standard C code.

So, it is nice not so much. It left Rcpp out of the matter. So, Is there a "short" way to develop a Rcpp interface that replaces (iii)?

By the moment I will try to ask about in the igraph help mailing list

Salut !

R statistics - Utilities: High Performance Computing, Rcpp Modules

2011-02-01T14:14:00.004-03:00

One of the possibilities within the Rcpp package is Rcpp modules. Lookat:

Exposing C++ functions and classes with Rcpp modules

Basically, the idea is that trough Rcpp modules, exposing C++ functions and classes to R (so they can be called and used from R) is to much easier than with the R API way, even it is easier than in the standard way provided trough Rcpp.

By the moment I will not discuss the technicalities involved here. It is something to just keep in mind.

A list of links that may be useful:

How to make Rcpp find a new module?
Using C++ libraries in an R package
Error using Rcpp

Salut !