| NEWS | R Documentation |
Changes in R code:
Prevent build failures on Windowsn when Rcpp is installed in a library path with spaces (transform paths in the same manner that R does before passing them to the build system).
Changes in Rcpp attributes:
Rcpp modules can now be used with sourceCpp
Standalone roxygen chunks (e.g. to document a class) are now transposed into RcppExports.R
Added Rcpp::plugins attribute for binding
directly to inline plugins. Plugins can be registered using
the new registerPlugin function.
Added built-in cpp11 plugin for specifying
the use of C++11 in a translation unit
Merge existing values of build related environment variables for sourceCpp
Add global package include file to RcppExports.cpp if it exists
Stop with an error if the file name passed to
sourceCpp has spaces in it
Return invisibly from void functions
Ensure that line comments invalidate block comments when parsing for attributes
Eliminated spurious empty hello world function definition in Rcpp.package.skeleton
Changes in Rcpp API:
The very central use of R API R_PreserveObject and R_ReleaseObject has been replaced by a new system based on the functions Rcpp_PreserveObject, Rcpp_ReleaseObject and Rcpp_ReplaceObject which shows better performance and is implemented using a generic vector treated as a stack instead of a pairlist in the R implementation. However, as this preserve / release code is still a little rough at the edges, a new #define is used (in config.h) to disable it for now.
Platform-dependent code in Timer.cpp now recognises a few more BSD variants thanks to contributed defined() test suggestions
Support for wide character strings has been added throughout the API. In particular String, CharacterVector, wrap and as are aware of wide character strings
Changes in Rcpp API:
Source and header files were reorganized and consolidated so that compile time are now significantly lower
Added additional check in Rstreambuf deletetion
Added support for clang++ when using libc++,
and for anc icpc in std=c++11 mode, thanks to a
patch by Yan Zhou
New class Rcpp::String to facilitate working with a single
element of a character vector
New utility class sugar::IndexHash inspired from Simon Urbanek's fastmatch package
Implementation of the equality operator between two Rcomplex
RNGScope now has an internal counter that enables it
to be safely used multiple times in the same stack frame.
New class Rcpp::Timer for benchmarking
Changes in Rcpp sugar:
More efficient version of match based on IndexHash
More efficient version of unique base on IndexHash
More efficient version of in base on IndexHash
More efficient version of duplicated base on IndexHash
More efficient version of self_match base on IndexHash
New function collapse that implements paste(., collapse= "" )
Changes in Rcpp attributes:
Use code generation rather than modules to implement
sourceCpp and compileAttributes (eliminates
problem with exceptions not being able to cross shared library
boundaries on Windows)
Exported functions now automatically establish an RNGScope
Functions exported by sourceCpp now directly
reference the external function pointer rather than rely on
dynlib lookup
On Windows, Rtools is automatically added to the PATH
during sourceCpp compilations
Diagnostics are printed to the console if sourceCpp
fails and C++ development tools are not installed
A warning is printed if when compileAttributes detects
Rcpp::depends attributes in source files that are not
matched by Depends/LinkingTo entries in the package DESCRIPTION
Changes in Rcpp sugar:
New functions: setdiff, union_, intersect
setequal, in, min, max, range,
match, table, duplicated
New function: clamp which combines pmin and pmax, e.g.
clamp( a, x, b) is the same as pmax( b, pmin(x, a) )
New function: self_match which implements something
similar to match( x, unique( x ) )
Changes in Rcpp API:
The Vector template class (hence NumericVector
...) get the is_na and the get_na static methods.
New helper class no_init that can be used to
create a vector without initializing its data, e.g. :
IntegerVector out = no_init(n) ;
New exception constructor requiring only a message; stop
function to throw an exception
DataFrame gains a nrows method
Changes in Rcpp attributes:
Ability to embed R code chunks (via specially formatted block comments) in C++ source files.
Allow specification of argument defaults for exported functions.
New scheme for more flexible mixing of generated and user composed C++ headers.
Print warning if no export attributes are found in source file.
Updated vignette with additional documentation on exposing C++ interfaces from packages and signaling errors.
Changes in Rcpp modules:
Enclose .External invocations in BEGIN_RCPP/END_RCPP
Changes in R code :
New function areMacrosDefined
Additions to Rcpp.package.skeleton:
attributes parameter to generate a version of
rcpp_hello_world that uses Rcpp::export.
cpp_files parameter to provide a list of C++
files to include the in the src directory of the package.
Miscellaneous changes:
New example 'pi simulation' using R and C++ via Rcpp attributes
Support for C++11 style attributes (embedded in comments) to enable use of C++ within interactive sessions and to automatically generate module declarations for packages:
Rcpp::export attribute to export a C++ function to R
sourceCpp() function to source exported functions from a file
cppFunction() and evalCpp() functions for inline declarations
and execution
compileAttribtes() function to generate Rcpp modules from
exported functions within a package
Rcpp::depends attribute for specifying additional build
dependencies for sourceCpp()
Rcpp::interfaces attribute to specify the external bindings
compileAttributes() should generate (defaults to R-only but a
C++ include file using R_GetCCallable can also be generated)
New vignette "Rcpp-attribute"
Rcpp modules feature set has been expanded:
Functions and methods can now return objects from classes that
are exposed through modules. This uses the make_new_object template
internally. This feature requires that some class traits are declared
to indicate Rcpp's wrap/as system that these classes are covered
by modules. The macro RCPP_EXPOSED_CLASS and RCPP_EXPOSED_CLASS_NODECL
can be used to declared these type traits.
Classes exposed through modules can also be used as parameters of exposed functions or methods.
Exposed classes can declare factories with ".factory". A factory is a c++ function that returns a pointer to the target class. It is assumed that these objects are allocated with new on the factory. On the R side, factories are called just like other constructors, with the "new" function. This feature allows an alternative way to construct objects.
"converter" can be used to declare a way to convert an object of a type to another type. This gets translated to the appropriate "as" method on the R side.
Inheritance. A class can now declare that it inherits from another class with the .derives<Parent>( "Parent" ) notation. As a result the exposed class gains methods and properties (fields) from its parent class.
New sugar functions:
which_min implements which.min. Traversing the sugar expression
and returning the index of the first time the minimum value is found.
which_max idem
unique uses unordered_set to find unique values. In particular,
the version for CharacterVector is found to be more efficient than
R's version
sort_unique calculates unique values and then sorts them.
Improvements to output facilities:
Implemented sync() so that flushing output streams works
Added Rcerr output stream (forwarding to
REprintf)
Provide a namespace 'R' for the standalone Rmath library so that Rcpp users can access those functions too; also added unit tests
Development releases sets variable RunAllRcppTests to yes to run all tests (unless it was alredy set to 'no'); CRAN releases do not and still require setting – which helps with the desired CRAN default of less testing at the CRAN server farm.
Untangling the clang++ build issue about the location of the exceptions header by directly checking for the include file – an approach provided by Martin Morgan in a kindly contributed patch as unit tests for them.
The Date and Datetime types now correctly
handle NA, NaN and Inf representation; the
Date type switched to an internal representation via double
Added Date and Datetime unit tests for the new
features
An additional PROTECT was added for parsing exception
messages before returning them to R, following a report by Ben North
Added new Rcpp sugar functions trunc(), round() and signif(), as well as unit tests for them
Be more conservative about where we support clang++ and the inclusion of exception_defines.h and prevent this from being attempted on OS X where it failed for clang 3.1
Corrected a typo in Module.h which now again permits use of finalizers
Small correction for (unexported) bib() function (which provides a path to the bibtex file that ships with Rcpp)
Converted NEWS to NEWS.Rd
Truly corrected Rcpp::Environment class by having default constructor use the global environment, and removing the default argument of global environment from the SEXP constructor
Added tests for clang++ version to include bits/exception_defines.h for versions 3.0 or higher (similar to g++ 4.6.0 or later), needed to include one particular exceptions header
Made more regression tests conditional on the RunAllRcppTests to come closer to the CRAN mandate of running tests in sixty seconds
Updated unit test wrapper tests/doRUnit.R as well as unitTests/runTests.R
Corrected Rcpp::Environment class by removing (empty) ctor following rev3592 (on May 2) where default argument for ctor was moved
Unit testing now checks for environment variable RunAllRcppTests being set to "yes"; otherwise some tests are skipped. This is arguably not the right thing to do, but CRAN maintainers insist on faster tests.
Unit test wrapper script runTests.R has new option –allTests to set the environment variable
The cleanup script now also considers inst/unitTests/testRcppClass/src
New member function for vectors (and lists etc) containsElementNamed() which returns a boolean indicating if the given element name is present
Updated the Rcpp.package.skeleton() support for Rcpp modules by carrying functions already present from the corresponding unit test which was also slightly expanded; and added more comments to the code
Rcpp modules can now be loaded via loadRcppModules() from .onLoad(), or via loadModule("moduleName") from any R file
Extended functionality to let R modify C++ clases imported via modules documented in help(setRcppClass)
Support compilation in Cygwin thanks to a patch by Dario Buttari
Extensions to the Rcpp-FAQ and the Rcpp-modules vignettes
The minium version of R is now 2.15.1 which is required for some of the Rcpp modules support
Rearrange headers so that Rcpp::Rcout can be used by RcppArmadillo et al
New Rcpp sugar function mapply (limited to two or three input vectors)
Added custom version of the Rcpp sugar diff function for numeric vectors skipping unncesserry checks for NA
Some internal code changes to reflect changes and stricter requirements in R CMD check in the current R-devel versions
Corrected fixed-value initialization for IntegerVector (with thanks to Gregor Kastner for spotting this)
New Rcpp-FAQ entry on simple way to set compiler option for cxxfunction
Reverting the 'int64' changes from release 0.9.8 which adversely affect packages using Rcpp: We will re-apply the 'int64' changes in a way which should cooperate more easily with 'long' and 'unsigned long'.
Unit test output directory fallback changed to use Rcpp.Rcheck
Conditioned two unit tests to not run on Windows where they now break whereas they passed before, and continue to pass on other OSs
wrap now handles 64 bit integers (int64_t, uint64_t) and containers of them, and Rcpp now depends on the int64 package (also on CRAN). This work has been sponsored by the Google Open Source Programs Office.
Added setRcppClass() function to create extended reference classes with an interface to a C++ class (typically via Rcpp Module) which can have R-based fields and methods in addition to those from the C++.
Applied patch by Jelmer Ypma which adds an output stream class 'Rcout' not unlike std::cout, but implemented via Rprintf to cooperate with R and its output buffering.
New unit tests for pf(), pnf(), pchisq(), pnchisq() and pcauchy()
XPtr constructor now checks for corresponding type in SEXP
Updated vignettes for use with updated highlight package
Update linking command for older fastLm() example using external Armadillo
Applied two patches kindly provided by Martyn Plummer which provide support for compilation on Solaris using the SunPro compiler
Minor code reorganisation in which exception specifiers are removed; this effectively only implements a run-time (rather than compile-time) check and is generally seen as a somewhat depreated C++ idiom. Thanks to Darren Cook for alerting us to this issue.
New example 'OpenMPandInline.r' in the OpenMP/ directory, showing how easily use OpenMP by modifying the RcppPlugin output
New example 'ifelseLooped.r' showing Rcpp can accelerate loops that may be difficult to vectorise due to dependencies
New example directory examples/Misc/ regrouping the new example as well as the fibonacci example added in Rcpp 0.9.6
New Rcpp-FAQ example warning of lossy conversion from 64-bit long integer types into a 53-bit mantissa which has no clear fix yet.
New unit test for accessing a non-exported function from a namespace
Added helper traits to facilitate implementation of the RcppEigen package: The is_eigen_base traits identifies if a class derives from EigenBase using SFINAE; and new dispatch layer was added to wrap() to help RcppEigen
XPtr now accepts a second template parameter, which is a function taking a pointer to the target class. This allows the developper to supply his/her own finalizer. The template parameter has a default value which retains the original behaviour (calling delete on the pointer)
New example RcppGibbs, extending Sanjog Misra's Rcpp illustration of Darren Wilkinson's comparison of MCMC Gibbs Sampler implementations; also added short timing on Normal and Gaussian RNG draws between Rcpp and GSL as R's rgamma() is seen to significantly slower
New example on recursively computing a Fibonacci number using Rcpp and comparing this to R and byte-compiled R for a significant speed gain
New Rcpp-FAQ examples on using the plugin maker for inline's cxxfunction(), and on setting row and column names for matrices
New sugar functions: mean, var, sd
Minor correction and extension to STL documentation in Rcpp-quickref
wrap() is now resilient to NULL pointers passed as in const char *
loadRcppModules() gains a "direct" argument to expose the module instead of exposing what is inside it
Suppress a spurious warning from R CMD check on packages created with Rcpp.package.skeleton(..., module=TRUE)
Some fixes and improvements for Rcpp sugar function 'rlnorm()'
Beginnings of new example using OpenMP and recognising user interrupts
New R function "loadRcppModules" to load Rcpp modules automatically from a package. This function must be called from the .onLoad function and works with the "RcppModules" field of the package's DESCRIPTION file
The Modules example wrapped the STL std::vector received some editing to disambiguate some symbols the newer compilers did not like
Coercing of vectors of factors is now done with an explicit callback to R's "as.character()" as Rf_coerceVector no longer plays along
A CITATION file for the published JSS paper has been added, and references were added to Rcpp-package.Rd and the different vignettes
Fixed a bug in which modules code was not behaving when compiled twice as can easily happen with inline'ed version
Exceptions code includes exception_defines.h only when g++ is 4.5 or younger as the file no longer exists with g++-4.6
The documentation Makefile now uses the $R_HOME environment variable
The documentation Makefile no longer calls clean in the all target
C++ conformance issue found by clang/llvm addressed by re-ordering declarations in grow.h as unqualified names must be declared before they are used, even when used within templates
The 'long long' typedef now depends on C++0x being enabled as this was not a feature in C++98; this suppresses a new g++-4.5 warning
The Rcpp-introduction vignette was updated to the forthcoming JSS paper
The unitTest runit.Module.client.package.R is now skipped on older OS X releases as it triggers a bug with g++ 4.2.1 or older; OS X 10.6 is fine but as it no longer support ppc we try to accomodate 10.5 too Thanks to Simon Urbanek for pinning this down and Baptiste Auguie and Ken Williams for additonal testing
RcppCommon.h now recognises the Intel Compiler thanks to a short patch by Alexey Stukalov; this turns off Cxx0x and TR1 features too
Three more setup questions were added to the Rcpp-FAQ vignette
One question about RcppArmadillo was added to the Rcpp-FAQ vignette
A number of internal changes to the memory allocation / protection of temporary objects were made—with a heartfelt "Thank You!" to both Doug Bates for very persistent debugging of Rcpp modules code, and to Luke Tierney who added additional memory allocation debugging tools to R-devel (which will be in R 2.13.0 and may also be in R 2.12.2)
Removed another GNU Make-specific variable from src/Makevars in order to make the build more portable; this was noticed on FreeBSD
On *BSD, do not try to compute a stack trace but provide file and line number (which is the same behaviour as implemented in Windows)
Fixed an int conversion bug reported by Daniel Sabanes Bove on r-devel, added unit test as well
Added unit tests for complex-typed vectors (thanks to Christian Gunning)
Expanded the Rcpp-quickref vignette (with thanks to Christian Gunning)
Additional examples were added to the Rcpp-FAQ vignette
The classic API was factored out into its own package RcppClassic which is released concurrently with this version.
If an object is created but not initialized, attempting to use it now gives a more sensible error message (by forwarding an Rcpp::not_initialized exception to R).
SubMatrix fixed, and Matrix types now have a nested ::Sub typedef.
New unexported function SHLIB() to aid in creating a shared library on the command-line or in Makefile (similar to CxxFlags() / LdFlags()).
Module gets a seven-argument ctor thanks to a patch from Tama Ma.
The (still incomplete) QuickRef vignette has grown thanks to a patch by Christian Gunning.
Added a sprintf template intended for logging and error messages.
Date::getYear() corrected (where addition of 1900 was not called for); corresponding change in constructor from three ints made as well.
Date() and Datetime() constructors from string received a missing conversion to int and double following strptime. The default format string for the Datetime() strptime call was also corrected.
A few minor fixes throughout, see ChangeLog.
Many improvements were made in 'Rcpp modules': - exposing multiple constructors - overloaded methods - self-documentation of classes, methods, constructors, fields and functions. - new R function "populate" to facilitate working with modules in packages. - formal argument specification of functions. - updated support for Rcpp.package.skeleton. - constructors can now take many more arguments.
The 'Rcpp-modules' vignette was updated as well and describe many of the new features
New template class Rcpp::SubMatrix<RTYPE> and support syntax in Matrix to extract a submatrix: NumericMatrix x = ... ; // extract the first three columns SubMatrix<REALSXP> y = x( _ , Range(0,2) ) ; // extract the first three rows SubMatrix<REALSXP> y = x( Range(0,2), _ ) ; // extract the top 3x3 sub matrix SubMatrix<REALSXP> y = x( Range(0,2), Range(0,2) ) ;
Reference Classes no longer require a default constructor for subclasses of C++ classes
Consistently revert to using backticks rather than shell expansion to compute library file location when building packages against Rcpp on the default platforms; this has been applied to internal test packages as well as CRAN/BioC packages using Rcpp
New syntactic shortcut to extract rows and columns of a Matrix. x(i,_) extracts the i-th row and x(_,i) extracts the i-th column.
Matrix indexing is more efficient. However, faster indexing is disabled if g++ 4.5.0 or later is used.
A few new Rcpp operators such as cumsum, operator=(sugar)
Variety of bug fixes: - column indexing was incorrect in some cases - compilation using clang/llvm (thanks to Karl Millar for the patch) - instantation order of Module corrected - POSIXct, POSIXt now correctly ordered for R 2.12.0
As of this version, Rcpp depends on R 2.12 or greater as it interfaces the new reference classes (see below) and also reflects the POSIXt class reordering both of which appeared with R version 2.12.0
new Rcpp::Reference class, that allows internal manipulation of R 2.12.0 reference classes. The class exposes a constructor that takes the name of the target reference class and a field(string) method that implements the proxy pattern to get/set reference fields using callbacks to the R operators "$" and "$<-" in order to preserve the R-level encapsulation
the R side of the preceding item allows methods to be written in R as per ?ReferenceClasses, accessing fields by name and assigning them using "<<-". Classes extracted from modules are R reference classes. They can be subclassed in R, and/or R methods can be defined using the $methods(...) mechanism.
internal performance improvements for Rcpp sugar as well as an added 'noNA()' wrapper to omit tests for NA values – see the included examples in inst/examples/convolveBenchmarks for the speedups
more internal performance gains with Functions and Environments
new macro RCPP_VERSION and Rcpp_Version to allow conditional compiling based on the version of Rcpp #if defined(RCPP_VERSION) && RCPP_VERSION >= Rcpp_Version(0,8,6) #endif
new sugar functions for statistical distributions (d-p-q-r functions) with distributions : unif, norm, gamma, chisq, lnorm, weibull, logis, f, pois, binom, t, beta.
new ctor for Vector taking size and function pointer so that for example NumericVector( 10, norm_rand ) generates a N(0,1) vector of size 10
added binary operators for complex numbers, as well as sugar support
more sugar math functions: sqrt, log, log10, exp, sin, cos, ...
started new vignette Rcpp-quickref : quick reference guide of Rcpp API (still work in progress)
various patches to comply with solaris/suncc stricter standards
minor enhancements to ConvolutionBenchmark example
simplified src/Makefile to no longer require GNU make; packages using Rcpp still do for the compile-time test of library locations
speed improvements. Vector::names, RObject::slot have been improved to take advantage of R API functions instead of callbacks to R
Some small updates to the Rd-based documentation which now points to content in the vignettes. Also a small formatting change to suppress a warning from the development version of R.
Minor changes to Date() code which may reenable SunStudio builds
new sugar vector functions: rep, rep_len, rep_each, rev, head, tail, diag
sugar has been extended to matrices: The Matrix class now extends the Matrix_Base template that implements CRTP. Currently sugar functions for matrices are: outer, col, row, lower_tri, upper_tri, diag
The unit tests have been reorganised into fewer files with one call each to cxxfunction() (covering multiple tests) resulting in a significant speedup
The Date class now uses the same mktime() replacement that R uses (based on original code from the timezone library by Arthur Olson) permitting wide date ranges on all operating systems
The FastLM example has been updated, a new benchmark based on the historical Longley data set has been added
RcppStringVector now uses std::vector<std::string> internally
setting the .Data slot of S4 objects did not work properly
This release adds Rcpp sugar which brings (a subset of) the R syntax into C++. This supports : - binary operators : <,>,<=,>=,==,!= between R vectors - arithmetic operators: +,-,*,/ between compatible R vectors - several functions that are similar to the R function of the same name: abs, all, any, ceiling, diff, exp, ifelse, is_na, lapply, pmin, pmax, pow, sapply, seq_along, seq_len, sign Simple examples : // two numeric vector of the same size NumericVector x ; NumericVector y ; NumericVector res = ifelse( x < y, x*x, -(y*y) ) ; // sapply'ing a C++ function double square( double x ){ return x*x ; } NumericVector res = sapply( x, square ) ; Rcpp sugar uses the technique of expression templates, pioneered by the Blitz++ library and used in many libraries (Boost::uBlas, Armadillo). Expression templates allow lazy evaluation of expressions, which coupled with inlining generates very efficient code, very closely approaching the performance of hand written loop code, and often much more efficient than the equivalent (vectorized) R code. Rcpp sugar is curently limited to vectors, future releases will include support for matrices with sugar functions such as outer, etc ... Rcpp sugar is documented in the Rcpp-sugar vignette, which contains implementation details.
New helper function so that "Rcpp?something" brings up Rcpp help
Rcpp Modules can now expose public data members
New classes Date, Datetime, DateVector and DatetimeVector with proper 'new' API integration such as as(), wrap(), iterators, ...
The so-called classic API headers have been moved to a subdirectory classic/ This should not affect client-code as only Rcpp.h was ever included.
RcppDate now has a constructor from SEXP as well
RcppDateVector and RcppDatetimeVector get constructors from int and both const / non-const operator(int i) functions
New API class Rcpp::InternalFunction that can expose C++ functions to R without modules. The function is exposed as an S4 object of class C++Function
Bug-fix release for suncc compiler with thanks to Brian Ripley for additional testing.
This release adds Rcpp modules. An Rcpp module is a collection of internal (C++) functions and classes that are exposed to R. This functionality has been inspired by Boost.Python. Modules are created internally using the RCPP_MODULE macro and retrieved in the R side with the Module function. This is a preview release of the module functionality, which will keep improving until the Rcpp 0.9.0 release. The new vignette "Rcpp-modules" documents the current feature set of Rcpp modules.
The new vignette "Rcpp-package" details the steps involved in making a package that uses Rcpp.
The new vignette "Rcpp-FAQ" collects a number of frequently asked questions and answers about Rcpp.
The new vignette "Rcpp-extending" documents how to extend Rcpp with user defined types or types from third party libraries. Based on our experience with RcppArmadillo
Rcpp.package.skeleton has been improved to generate a package using an Rcpp module, controlled by the "module" argument
Evaluating a call inside an environment did not work properly
cppfunction has been withdrawn since the introduction of the more flexible cxxfunction in the inline package (0.3.5). Rcpp no longer depends on inline since many uses of Rcpp do not require inline at all. We still use inline for unit tests but this is now handled locally in the unit tests loader runTests.R. Users of the now-withdrawn function cppfunction can redefine it as: cppfunction <- function(...) cxxfunction( ..., plugin = "Rcpp" )
Support for std::complex was incomplete and has been enhanced.
The methods XPtr<T>::getTag and XPtr<T>::getProtected are deprecated, and will be removed in Rcpp 0.8.2. The methods tag() and prot() should be used instead. tag() and prot() support both LHS and RHS use.
END_RCPP now returns the R Nil values; new macro VOID_END_RCPP replicates prior behabiour
All Rcpp headers have been moved to the inst/include directory, allowing use of 'LinkingTo: Rcpp'. But the Makevars and Makevars.win are still needed to link against the user library.
Automatic exception forwarding has been withdrawn because of portability issues (as it did not work on the Windows platform). Exception forwarding is still possible but is now based on explicit code of the form: try { // user code } catch( std::exception& __ex__){ forward_exception_to_r( __ex___ ) ; Alternatively, the macro BEGIN_RCPP and END_RCPP can use used to enclose code so that it captures exceptions and forward them to R. BEGIN_RCPP // user code END_RCPP
new __experimental__ macros The macros RCPP_FUNCTION_0, ..., RCPP_FUNCTION_65 to help creating C++ functions hiding some code repetition: RCPP_FUNCTION_2( int, foobar, int x, int y){ return x + y ; The first argument is the output type, the second argument is the name of the function, and the other arguments are arguments of the C++ function. Behind the scenes, the RCPP_FUNCTION_2 macro creates an intermediate function compatible with the .Call interface and handles exceptions Similarly, the macros RCPP_FUNCTION_VOID_0, ..., RCPP_FUNCTION_VOID_65 can be used when the C++ function to create returns void. The generated R function will return R_NilValue in this case. RCPP_FUNCTION_VOID_2( foobar, std::string foo ){ // do something with foo The macro RCPP_XP_FIELD_GET generates a .Call compatible function that can be used to access the value of a field of a class handled by an external pointer. For example with a class like this: class Foo{ public: int bar ; RCPP_XP_FIELD_GET( Foo_bar_get, Foo, bar ) ; RCPP_XP_FIELD_GET will generate the .Call compatible function called Foo_bar_get that can be used to retrieved the value of bar. The macro RCPP_FIELD_SET generates a .Call compatible function that can be used to set the value of a field. For example: RCPP_XP_FIELD_SET( Foo_bar_set, Foo, bar ) ; generates the .Call compatible function called "Foo_bar_set" that can be used to set the value of bar The macro RCPP_XP_FIELD generates both getter and setter. For example RCPP_XP_FIELD( Foo_bar, Foo, bar ) generates the .Call compatible Foo_bar_get and Foo_bar_set using the macros RCPP_XP_FIELD_GET and RCPP_XP_FIELD_SET previously described The macros RCPP_XP_METHOD_0, ..., RCPP_XP_METHOD_65 faciliate calling a method of an object that is stored in an external pointer. For example: RCPP_XP_METHOD_0( foobar, std::vector<int> , size ) creates the .Call compatible function called foobar that calls the size method of the std::vector<int> class. This uses the Rcpp::XPtr< std::vector<int> > class. The macros RCPP_XP_METHOD_CAST_0, ... is similar but the result of the method called is first passed to another function before being wrapped to a SEXP. For example, if one wanted the result as a double RCPP_XP_METHOD_CAST_0( foobar, std::vector<int> , size, double ) The macros RCPP_XP_METHOD_VOID_0, ... are used when calling the method is only used for its side effect. RCPP_XP_METHOD_VOID_1( foobar, std::vector<int>, push_back ) Assuming xp is an external pointer to a std::vector<int>, this could be called like this : .Call( "foobar", xp, 2L )
Rcpp now depends on inline (>= 0.3.4)
A new R function "cppfunction" was added which invokes cfunction from inline with focus on Rcpp usage (enforcing .Call, adding the Rcpp namespace, set up exception forwarding). cppfunction uses BEGIN_RCPP and END_RCPP macros to enclose the user code
new class Rcpp::Formula to help building formulae in C++
new class Rcpp::DataFrame to help building data frames in C++
Rcpp.package.skeleton gains an argument "example_code" and can now be used with an empty list, so that only the skeleton is generated. It has also been reworked to show how to use LinkingTo: Rcpp
wrap now supports containers of the following types: long, long double, unsigned long, short and unsigned short which are silently converted to the most acceptable R type.
Revert to not double-quote protecting the path on Windows as this breaks backticks expansion used n Makevars.win etc
Exceptions classes have been moved out of Rcpp classes, e.g. Rcpp::RObject::not_a_matrix is now Rcpp::not_a_matrix
Undo shQuote() to protect Windows path names (which may contain spaces) as backticks use is still broken; use of $(shell ...) works
Vector<> gains a set of templated factory methods "create" which takes up to 20 arguments and can create named or unnamed vectors. This greatly facilitates creating objects that are returned to R.
Matrix now has a diag() method to create diagonal matrices, and a new constructor using a single int to create square matrices
Vector now has a new fill() method to propagate a single value
Named is no more a class but a templated function. Both interfaces Named(.,.) and Named(.)=. are preserved, and extended to work also on simple vectors (through Vector<>::create)
Applied patch by Alistair Gee to make ColDatum more robust
Fixed a bug in Vector that caused random behavior due to the lack of copy constructor in the Vector template
new class Rcpp::S4 whose constructor checks if the object is an S4 object
maximum number of templated arguments to the pairlist function, the DottedPair constructor, the Language constructor and the Pairlist constructor has been updated to 20 (was 5) and a script has been added to the source tree should we want to change it again
use shQuote() to protect Windows path names (which may contain spaces)
Another small improvement to Windows build flags
bugfix on 64 bit platforms. The traits classes (wrap_type_traits, etc) used size_t when they needed to actually use unsigned int
fixed pre gcc 4.3 compatibility. The trait class that was used to identify if a type is convertible to another had too many false positives on pre gcc 4.3 (no tr1 or c++0x features). fixed by implementing the section 2.7 of "Modern C++ Design" book.
All vector classes are now generated from the same template class Rcpp::Vector<int RTYPE> where RTYPE is one of LGLSXP, RAWSXP, STRSXP, INTSXP, REALSXP, CPLXSXP, VECSXP and EXPRSXP. typedef are still available : IntegerVector, ... All vector classes gain methods inspired from the std::vector template : push_back, push_front, erase, insert
New template class Rcpp::Matrix<RTYPE> deriving from Rcpp::Vector<RTYPE>. These classes have the same functionality as Vector but have a different set of constructors which checks that the input SEXP is a matrix. Matrix<> however does/can not guarantee that the object will allways be a matrix. typedef are defined for convenience: Matrix<INTSXP> is IntegerMatrix, etc...
New class Rcpp::Row<int RTYPE> that represents a row of a matrix of the same type. Row contains a reference to the underlying Vector and exposes a nested iterator type that allows use of STL algorithms on each element of a matrix row. The Vector class gains a row(int) method that returns a Row instance. Usage examples are available in the runit.Row.R unit test file
New class Rcpp::Column<int RTYPE> that represents a column of a matrix. (similar to Rcpp::Row<int RTYPE>). Usage examples are available in the runit.Column.R unit test file
The Rcpp::as template function has been reworked to be more generic. It now handles more STL containers, such as deque and list, and the genericity can be used to implement as for more types. The package RcppArmadillo has examples of this
new template class Rcpp::fixed_call that can be used in STL algorithms such as std::generate.
RcppExample et al have been moved to a new package RcppExamples; src/Makevars and src/Makevars.win simplified accordingly
New class Rcpp::StringTransformer and helper function Rcpp::make_string_transformer that can be used to create a function that transforms a string character by character. For example Rcpp::make_string_transformer(tolower) transforms each character using tolower. The RcppExamples package has an example of this.
Improved src/Makevars.win thanks to Brian Ripley
New examples for 'fast lm' using compiled code: - using GNU GSL and a C interface - using Armadillo (http://arma.sf.net) and a C++ interface Armadillo is seen as faster for lack of extra copying
A new package RcppArmadillo (to be released shortly) now serves as a concrete example on how to extend Rcpp to work with a modern C++ library such as the heavily-templated Armadillo library
Added a new vignette 'Rcpp-introduction' based on a just-submitted overview article on Rcpp
new template classes Rcpp::unary_call and Rcpp::binary_call that facilitates using R language calls together with STL algorithms.
fixed a bug in Language constructors taking a string as their first argument. The created call was wrong.
SEXP_Vector (and ExpressionVector and GenericVector, a.k.a List) now have methods push_front, push_back and insert that are templated
SEXP_Vector now has int- and range-valued erase() members
Environment class has a default constructor (for RInside)
SEXP_Vector_Base factored out of SEXP_Vector (Effect. C++ #44)
SEXP_Vector_Base::iterator added as well as begin() and end() so that STL algorithms can be applied to Rcpp objects
CharacterVector gains a random access iterator, begin() and end() to support STL algorithms; iterator dereferences to a StringProxy
Restore Windows build; successfully tested on 32 and 64 bit;
Small fixes to inst/skeleton files for bootstrapping a package
RObject::asFoo deprecated in favour of Rcpp::as<Foo>
wrap has been much improved. wrappable types now are : - primitive types : int, double, Rbyte, Rcomplex, float, bool - std::string - STL containers which have iterators over wrappable types: (e.g. std::vector<T>, std::deque<T>, std::list<T>, etc ...). - STL maps keyed by std::string, e.g std::map<std::string,T> - classes that have implicit conversion to SEXP - classes for which the wrap template if fully or partly specialized This allows composition, so for example this class is wrappable: std::vector< std::map<std::string,T> > (if T is wrappable)
The range based version of wrap is now exposed at the Rcpp:: level with the following interface : Rcpp::wrap( InputIterator first, InputIterator last ) This is dispatched internally to the most appropriate implementation using traits
a new namespace Rcpp::traits has been added to host the various type traits used by wrap
The doxygen documentation now shows the examples
A new file inst/THANKS acknowledges the kind help we got from others
The RcppSexp has been removed from the library.
The methods RObject::asFoo are deprecated and will be removed in the next version. The alternative is to use as<Foo>.
The method RObject::slot can now be used to get or set the associated slot. This is one more example of the proxy pattern
Rcpp::VectorBase gains a names() method that allows getting/setting the names of a vector. This is yet another example of the proxy pattern.
Rcpp::DottedPair gains templated operator<< and operator>> that allow wrap and push_back or wrap and push_front of an object
Rcpp::DottedPair, Rcpp::Language, Rcpp::Pairlist are less dependent on C++0x features. They gain constructors with up to 5 templated arguments. 5 was choosed arbitrarily and might be updated upon request.
function calls by the Rcpp::Function class is less dependent on C++0x. It is now possible to call a function with up to 5 templated arguments (candidate for implicit wrap)
added support for 64-bit Windows (thanks to Brian Ripley and Uwe Ligges)
matrix-like indexing using operator() for all vector types : IntegerVector, NumericVector, RawVector, CharacterVector LogicalVector, GenericVector and ExpressionVector.
new class Rcpp::Dimension to support creation of vectors with dimensions. All vector classes gain a constructor taking a Dimension reference.
an intermediate template class "SimpleVector" has been added. All simple vector classes are now generated from the SimpleVector template : IntegerVector, NumericVector, RawVector, CharacterVector LogicalVector.
an intermediate template class "SEXP_Vector" has been added to generate GenericVector and ExpressionVector.
the clone template function was introduced to explicitely clone an RObject by duplicating the SEXP it encapsulates.
even smarter wrap programming using traits and template meta-programming using a private header to be include only RcppCommon.h
the as template is now smarter. The template now attempts to build an object of the requested template parameter T by using the constructor for the type taking a SEXP. This allows third party code to create a class Foo with a constructor Foo(SEXP) to have as<Foo> for free.
wrap becomes a template. For an object of type T, wrap<T> uses implicit conversion to SEXP to first convert the object to a SEXP and then uses the wrap(SEXP) function. This allows third party code creating a class Bar with an operator SEXP() to have wrap for free.
all specializations of wrap : wrap<double>, wrap< vector<double> > use coercion to deal with missing values (NA) appropriately.
configure has been withdrawn. C++0x features can now be activated by setting the RCPP_CXX0X environment variable to "yes".
new template r_cast<int> to facilitate conversion of one SEXP type to another. This is mostly intended for internal use and is used on all vector classes
Environment now takes advantage of the augmented smartness of as and wrap templates. If as<Foo> makes sense, one can directly extract a Foo from the environment. If wrap<Bar> makes sense then one can insert a Bar directly into the environment. Foo foo = env["x"] ; /* as<Foo> is used */ Bar bar ; env["y"] = bar ; /* wrap<Bar> is used */
Environment::assign becomes a template and also uses wrap to create a suitable SEXP
Many more unit tests for the new features; also added unit tests for older API
New R function Rcpp.package.skeleton, modelled after utils::package.skeleton to help creating a package with support for Rcpp use.
indexing is now faster for simple vectors due to inlining of the operator[] and caching the array pointer
The class Rcpp::VectorBase was introduced. All vector classes derive from it. The class handles behaviour that is common to all vector types: length, names, etc ...
exception forwarding is extended to compilers other than GCC but default values are used for the exception class and the exception message, because we don't know how to do it.
Improved detection of C++0x capabilities
Rcpp::Pairlist gains a default constructor
Rcpp::Environment gains a new_child method to create a new environment whose parent is this
Rcpp::Environment::Binding gains a templated implicit conversion operator
Rcpp::ExpressionVector gains an eval method to evaluate itself
Rcpp::ExpressionVector gains a constructor taking a std::string representing some R code to parse.
Rcpp::GenericVector::Proxy gains an assignment operator to deal with Environment::Proxy objects
Rcpp::LdFlags() now defaults to static linking OS X, as it already did on Windows; this default can be overridden.
a new benchmark was added to the examples directory around the classic convolution example from Writing R extensions to compare C and C++ implementations
Rcpp::CharacterVector::StringProxy gains a += operator
Rcpp::Environment gains an operator[](string) to get/set objects from the environment. operator[] returns an object of class Rcpp::Environment::Binding which implements the proxy pattern. Inspired from Item 30 of 'More Effective C++'
Rcpp::Pairlist and Rcpp::Language gain an operator[](int) also using the proxy pattern
Rcpp::RObject.attr can now be used on the rhs or the lhs, to get or set an attribute. This also uses the proxy pattern
Rcpp::Pairlist and Rcpp::Language gain new methods push_back replace, length, size, remove, insert
wrap now returns an object of a suitable class, not just RObject anymore. For example wrap( bool ) returns a LogicalVector
Rcpp::RObject gains methods to deal with S4 objects : isS4, slot and hasSlot
new class Rcpp::ComplexVector to manage complex vectors (CPLXSXP)
new class Rcpp::Promise to manage promises (PROMSXP)
new class Rcpp::ExpressionVector to manage expression vectors (EXPRSXP)
new class Rcpp::GenericVector to manage generic vectors, a.k.a lists (VECSXP)
new class Rcpp::IntegerVector to manage integer vectors (INTSXP)
new class Rcpp::NumericVector to manage numeric vectors (REALSXP)
new class Rcpp::RawVector to manage raw vectors (RAWSXP)
new class Rcpp::CharacterVector to manage character vectors (STRSXP)
new class Rcpp::Function to manage functions (CLOSXP, SPECIALSXP, BUILTINSXP)
new class Rcpp::Pairlist to manage pair lists (LISTSXP)
new class Rcpp::Language to manage calls (LANGSXP)
new specializations of wrap to deal with std::initializer lists only available with GCC >= 4.4
new R function Rcpp:::capabilities that can query if various features are available : exception handling, variadic templates initializer lists
new set of functions wrap(T) converting from T to RObject
new template function as<T> that can be used to convert a SEXP to type T. Many specializations implemented to deal with C++ builtin and stl types. Factored out of RObject
new class Rcpp::Named to deal with named with named objects in a pairlist, or a call
new class Rcpp::Symbol to manage symbols (SYMSXP)
The garbage collection has been improved and is now automatic and hidden. The user needs not to worry about it at all.
Rcpp::Environment(SEXP) uses the as.environment R function
Doxygen-generated documentation is no longer included as it is both too large and too volatile. Zipfiles are provided on the website.
Romain is now a co-author of Rcpp
New base class Rcpp::RObject replace RcppSexp (which is provided for backwards compatibility)
RObject has simple wrappers for object creation and conversion to SEXP
New classes Rcpp::Evaluator and Rcpp::Environment for expression evaluation and environment access, respectively
New class Rcpp::XPtr for external pointers
Enhanced exception handling allows for trapping of exceptions outside of try/catch blocks
Namespace support with a new namespace 'Rcpp'
Unit tests for most of the new classes, based on the RUnit package
Inline support now provided by the update inline package, so a new Depends on 'inline (>= 0.3.4)' replaces the code in that was temporarily in Rcpp
Inline support via a modified version of 'cfunction' from Oleg Sklyar's 'inline' package: simple C++ programs can now be compiled, linked and loaded automagically from the R prompt, including support for external packages. Also works on Windows (with R-tools installed)
New examples for the inline support based on 'Intro to HPC' tutorials
New type RcppSexp for simple int, double, std::string scalars and vectors
Every class is now in its own header and source file
Fix to RcppParams.Rd thanks to Frank S. Thomas
RcppVersion.R removed as redundant given DESCRIPTION and read.dcf()
Switched to R_PreserveObject and R_ReleaseObject for RcppSexp with thanks to Romain
Licensing changed from LGPL 2.1 (or later) to GPL 2 (or later), file COPYING updated
Several classes now split off into their own header and source files
New header file RcppCommon.h regrouping common defines and includes
Makevars{,.win} updated to reflect src/ reorg
New class RcppList for simple lists and data structures of different types and dimensions, useful for RProtoBuf project on R-Forge
Started to split classes into their own header and source files
Added short README file about history and status
Small documentation markup fix thanks to Kurt; updated doxygen docs
New examples directory functionCallback/ for R function passed to C++ and being called
Updated Doxygen documentation
RcppParams class gains a new exists() member function
Small OS X build correction using R_ARCH variable
Include LGPL license as file COPYING
Use std:: namespace throughout instead of 'using namespace std'
Define R_NO_REMAP so that R provides Rf_length() etc in lieu of length() to minimise clashes with other projects having similar functions
Include Doxygen documentation, and Doxygen configuration file
Minor Windows build fix (with thanks to Uwe and Simon)
OS X build fix with thanks to Simon
Added 'view-only' classes for int and double vector and matrix clases as well as string vector classses, kindly suggsted / provided by David Reiss
Add two shorter helper functions Rcpp:::CxxFlags() and Rcpp:::LdFlags() for compilation and linker flags
Small but important fix for Linux builds in Rcpp:::RcppLdFlags()
Now src/Makevars replaces src/Makefile, this brings proper OS X multi-arch support with thanks to Simon
Old #ifdef statements related to QuantLib removed; Rcpp is now decoupled from QuantLib headers yet be used by RQuantLib
Added RcppLdPath() to return the lib. directory patch and on Linux the rpath settings
Added new RcppVectorExample()
Augmented documentation on usage in Rcpp-package.Rd
New maintainer, taking over RcppTemplate (which has been without an update since Nov 2006) under its initial name Rcpp
New files src/Makefile{,.win} including functionality from both configure and RcppSrc/Makefile; we now build two libraries, one for use by the package which also runs the example, and one for users to link against, and removed src/Makevars.in
Files src/Rcpp.{cpp,h} moved in from ../RcppSrc
Added new class RcppDatetime corresponding to POSIXct in with full support for microsecond time resolution between R and C++
Several new manual pages added
Removed configure{,.in,.win} as src/Makefile* can handle this more easily
Minor cleanup and reformatting for DESCRIPTION, Date: now uses svn:keyword Date property
Renamed RcppTemplateVersion to RcppVersion, deleted RcppDemo
Directory demo/ removed as vignette("RcppAPI") is easier and more reliable to show vignette documentation
RcppTemplateDemo() removed from R/zzz.R, vignette("RcppAPI") is easier; man/RcppTemplateDemo.Rd removed as well
Some more code reindentation and formatting to R default arguments, some renamed from RcppTemplate* to Rcpp*
Added footnote onto titlepage of inst/doc/RcppAPI.{Rnw,pdf} about how this document has not (yet) been updated along with the channges made