News for Package Rcpp

Changes in Rcpp release version 1.0.13-1 (2024-11-01)

• Changes in Rcpp API:

  • Use read-only VECTOR_PTR and STRING_PTR only with with R 4.5.0 or later (Kevin in #1342 fixing #1341)

• Changes in Rcpp Deployment:

  • Authors@R is now used in DESCRIPTION as mandated by CRAN

Changes in Rcpp release version 1.0.13 (2024-07-11)

• Changes in Rcpp API:

  • Set R_NO_REMAP if not already defined (Dirk in #1296)

  • Add variadic templates to be used instead of generated code (Andrew Johnson in #1303)

  • Count variables were switches to size_t to avoid warnings about conversion-narrowing (Dirk in #1307)

  • Rcpp now avoids the usage of the (non-API) DATAPTR function when accessing the contents of Rcpp Vector objects where possible. (Kevin in #1310)

  • Rcpp now emits an R warning on out-of-bounds Vector accesses. This may become an error in a future Rcpp release. (Kevin in #1310)

  • Switch VECTOR_PTR and STRING_PTR to new API-compliant RO variants (Kevin in #1317 fixing #1316)

• Changes in Rcpp Deployment:

  • Small updates to the CI test containers have been made (#1304)

Changes in Rcpp release version 1.0.12 (2024-01-08)

• Changes in Rcpp API:

  • Missing header includes as spotted by some recent tools were added in two places (Michael Chirico in #1272 closing #1271).

  • Casts to avoid integer overflow in matrix row/col selections have neem added (Aaron Lun #1281).

  • Three print format correction uncovered by R-devel were applied with thanks to Tomas Kalibera (Dirk in #1285).

  • Correct a print format correction in the RcppExports glue code (Dirk in #1288 fixing #1287).

  • The upcoming OBJSXP addition to R 4.4.0 is supported in the type2name mapper (Dirk and Iñaki in #1293).

• Changes in Rcpp Attributes:

  • Generated interface code from base R that fails under LTO is now corrected (Iñaki in #1274 fixing a StackOverflow issue).

• Changes in Rcpp Documentation:

  • The caption for third figure in the introductory vignette has been corrected (Dirk in #1277 fixing #1276).

  • A small formatting issue was correct in an Rd file as noticed by R-devel (Dirk in #1282).

  • The Rcpp FAQ vignette has been updated (Dirk in #1284).

  • The Rcpp.bib file has been refreshed to current package versions.

• Changes in Rcpp Deployment:

  • The RcppExports file for an included test package has been updated (Dirk in #1289).

Changes in Rcpp release version 1.0.11 (2023-07-03)

• Changes in Rcpp API:

  • Rcpp:::CxxFlags() now quotes only non-standard include path on linux (Lukasz in #1243 closing #1242).

  • Two unit tests no longer accidentally bark on stdout (Dirk and Iñaki in #1245).

  • Compilation under C++20 using clang++ and its standard library is enabled (Dirk in #1248 closing #1244).

  • Use backticks in a generated .Call() statement in RcppExports.R (Dirk #1256 closing #1255).

  • Switch to system2() to capture standard error messages in error cases (Iñaki in #1259 and #1261 fixing #1257).

• Changes in Rcpp Documentation:

  • The CITATION file format has been updated (Dirk in #1250 fixing #1249).

• Changes in Rcpp Deployment:

  • A test for qnorm now uses the more accurate value from R 4.3.0 (Dirk in #1252 and #1260 fixing #1251).

  • Skip tests with path issues on Windows (Iñaki in #1258).

  • Container deployment in continuous integrations was improved. (Iñaki and Dirk in #1264, Dirk in #1269).

  • Several files receives minor edits to please R CMD check from r-devel (Dirk in #1267).

Changes in Rcpp release version 1.0.10 (2023-01-12)

• Changes in Rcpp API:

  • Unwind protection is enabled by default (Iñaki in #1225). It can be disabled by defining RCPP_NO_UNWIND_PROTECT before including Rcpp.h. RCPP_USE_UNWIND_PROTECT is not checked anymore and has no effect. The associated plugin unwindProtect is therefore deprecated and will be removed in a future release.

  • The 'finalize' method for Rcpp Modules is now eagerly materialized, fixing an issue where errors can occur when Module finalizers are run (Kevin in #1231 closing #1230).

  • Zero-row data.frame objects can receive push_back or push_front (Dirk in #1233 fixing #1232).

  • One remaining sprintf has been replaced by snprintf (Dirk and Kevin in #1236 and #1237).

  • Several conversion warnings found by clang++ have been addressed (Dirk in #1240 and #1241).

• Changes in Rcpp Attributes:

  • The C++20, C++2b (experimental) and C++23 standards now have plugin support like the other C++ standards (Dirk in #1228).

  • The source path for attributes received one more protection from spaces (Dirk in #1235 addressing #1234).

• Changes in Rcpp Deployment:

  • Several GitHub Actions have been updated.

Changes in Rcpp release version 1.0.9 (2022-07-02)

• Changes in Rcpp API:

  • Accomodate C++98 compilation by adjusting attributes.cpp (Dirk in #1193 fixing #1192)

  • Accomodate newest compilers replacing deprecated std::unary_function and std::binary_function with std::function (Dirk in #1202 fixing #1201 and CRAN request)

  • Upon removal from precious list, the tag is set to null (Iñaki in #1205 fixing #1203)

  • Move constructor and assignment for strings have been added (Dean Scarff in #1219).

• Changes in Rcpp Documentation:

  • Adjust one overflowing column (Bill Denney in #1196 fixing #1195)

  • Correct a typo in the FAQ (Marco Colombo in #1217)

• Changes in Rcpp Deployment:

  • Accomodate four digit version numbers in unit test (Dirk)

  • Do not run complete test suite to limit test time to CRAN preference (Dirk in #1206)

  • Small updates to the CI test containers have been made

  • Some of changes also applied to an interim release 1.0.8.3 made for CRAN on 2022-03-14.

Changes in Rcpp release version 1.0.8 (2022-01-11)

• Changes in Rcpp API:

  • STRICT_R_HEADERS is now enabled by default, see extensive discussion in #1158 closing #898.

  • A new #define allows default setting of finalizer calls for external pointers (Iñaki in #1180 closing #1108).

  • Rcpp:::CxxFlags() now quotes the include path generated, (Kevin in #1189 closing #1188).

  • New header files Rcpp/Light, Rcpp/Lighter, Rcpp/Lightest and default Rcpp/Rcpp for fine-grained access to features (and compilation time) (Dirk #1191 addressing #1168).

• Changes in Rcpp Attributes:

  • A new option signature allows customization of function signatures (Travers Ching in #1184 and #1187 fixing #1182)

• Changes in Rcpp Documentation:

  • The Rcpp FAQ has a new entry on how not to grow a vector (Dirk in #1167).

  • Some long-spurious calls to RNGSope have been removed from examples (Dirk in #1173 closing #1172).

  • DOI reference in the bibtex files have been updated per JSS request (Dirk in #1186).

• Changes in Rcpp Deployment:

  • Some continuous integration components have been updated (Dirk in #1174, #1181, and #1190).

Changes in Rcpp release version 1.0.7 (2021-07-06)

• Changes in Rcpp API:

  • Refactored Rcpp_PreserveObject and Rcpp_ReleaseObject which are now O(1) (Dirk and Iñaki in #1133 and #1135 fixing #382 and #1081).

  • A spuriously assigned variable was removed (Dirk in #1138 fixing #1137).

  • Global Rcout and Rcerr objects are supported via a compiler directive (Iñaki in #1139 fixing #928)

  • Add support for Rcpp::message (Dirk in #1146 fixing #1145).

  • The uint32_t type is used throughout instead of unsigned int (Dirk in #1153 fixing #1152).

  • The cfloat header for floating point limits is now included (Dirk in #1162 fixing #1161).

• Changes in Rcpp Attributes:

  • Packages with dots in their name can now have per-package include files (Dirk in #1132 fixing #1129).

  • New argument echo to quieten optional evaluation in sourceCpp (Dirk in #1138 fixing #1126).

• Forthcoming Changes in Rcpp API:

  • Starting with Rcpp 1.0.8 anticipated in January 2022, STRICT_R_HEADERS will be enabled by default, see #1126.

Changes in Rcpp release version 1.0.6 (2021-01-14)

• Changes in Rcpp API:

  • Replace remaining few uses of EXTPTR_PTR with R_ExternalPtrAddr (Kevin in #1098 fixing #1097).

  • Add push_back and push_front for DataFrame (Walter Somerville in #1099 fixing #1094).

  • Remove a misleading-to-wrong comment (Mattias Ellert in #1109 cleaning up after #1049).

  • Address a sanitizer report by initializing two private bool variables (Benjamin Christoffersen in #1113).

  • External pointer finalizer toggle default values were corrected to true (Dirk in #1115).

• Changes in Rcpp Documentation:

  • Several URLs were updated to https and/or new addresses (Dirk).

• Changes in Rcpp Deployment:

  • Added GitHub Actions CI using the same container-based setup used previously, and also carried code coverage over (Dirk in #1128).

• Changes in Rcpp support functions:

  • Rcpp.package.skeleton() avoids warning from R. (Dirk)

Changes in Rcpp release version 1.0.5 (2020-07-01)

• Changes in Rcpp API:

  • The exception handler code in #1043 was updated to ensure proper include behavior (Kevin in #1047 fixing #1046).

  • A missing Rcpp_list6 definition was added to support R 3.3.* builds (Davis Vaughan in #1049 fixing #1048).

  • Missing Rcpp_list{2,3,4,5} definition were added to the Rcpp namespace (Dirk in #1054 fixing #1053).

  • A further updated corrected the header include and provided a missing else branch (Mattias Ellert in #1055).

  • Two more assignments are protected with Rcpp::Shield (Dirk in #1059).

  • One call to abs is now properly namespaced with std:: (Uwe Korn in #1069).

  • String object memory preservation was corrected/simplified (Kevin in #1082).

• Changes in Rcpp Attributes:

  • Empty strings are not passed to R CMD SHLIB which was seen with R 4.0.0 on Windows (Kevin in #1062 fixing #1061).

  • The short_file_name() helper function is safer with respect to temporaries (Kevin in #1067 fixing #1066, and #1071 fixing #1070).

• Changes in Rcpp Sugar:

  • Two sample() objects are now standard vectors and not R_alloc created (Dirk in #1075 fixing #1074).

• Changes in Rcpp support functions:

  • Rcpp.package.skeleton() adjusts for a (documented) change in R 4.0.0 (Dirk in #1088 fixing #1087).

• Changes in Rcpp Documentation:

  • The pdf file of the earlier introduction is again typeset with bibliographic information (Dirk).

  • A new vignette describing how to package C++ libraries has been added (Dirk in #1078 fixing #1077).

• Changes in Rcpp Deployment:

  • Travis CI unit tests now run a matrix over the versions of R also tested at CRAN (rel/dev/oldrel/oldoldrel), and coverage runs in parallel for a net speed-up (Dirk in #1056 and #1057).

  • The exceptions test is now partially skipped on Solaris as it already is on Windows (Dirk in #1065).

  • The default CI runner was upgraded to R 4.0.0 (Dirk).

  • The CI matrix spans R 3.5, 3.6, r-release and r-devel (Dirk).

Changes in Rcpp version 1.0.4 (2020-03-13)

• Changes in Rcpp API:

  • Safer Rcpp_list*, Rcpp_lang* and Function.operator() (Romain in #1014, #1015).

  • A number of #nocov markers were added (Dirk in #1036, #1042 and #1044).

  • Finalizer calls clear external pointer first (Kirill Müller and Dirk in #1038).

  • Scalar operations with a rhs matrix no longer change the matrix value (Qiang in #1040 fixing (again) #365).

  • Rcpp::exception and Rcpp::stop are now more thread-safe (Joshua Pritikin in #1043).

• Changes in Rcpp Attributes:

  • The cppFunction helper now deals correctly with mulitple depends arguments (TJ McKinley in #1016 fixing #1017).

  • Invisible return objects are now supported via new option (Kun Ren in #1025 fixing #1024).

  • Unavailable packages referred to in LinkingTo are now reported (Dirk in #1027 fixing #1026).

  • The sourceCpp function can now create a debug DLL on Windows (Dirk in #1037 fixing #1035).

• Changes in Rcpp Documentation:

  • The .github/ directory now has more explicit guidance on contributing, issues, and pull requests (Dirk).

  • The Rcpp Attributes vignette describe the new invisible return object option (Kun Ren in #1025).

  • Vignettes are now included as pre-made pdf files (Dirk in #1029)

  • The Rcpp FAQ has a new entry on the recommended importFrom directive (Dirk in #1031 fixing #1030).

  • The bib file for the vignette was once again updated to current package versions (Dirk).

• Changes in Rcpp Deployment:

  • Added unit test to check if C++ version remains remains aligned with the package number (Dirk in #1022 fixing #1021).

  • The unit test system was switched to tinytest (Dirk in #1028, #1032, #1033).

Changes in Rcpp version 1.0.3 (2019-11-08)

• Changes in Rcpp API:

  • Compilation can be sped up by skipping Modules headers via a toggle RCPP_NO_MODULES (Kevin in #995 for #993).

  • Compilation can be sped up by toggling RCPP_NO_RTTI which implies RCPP_NO_MODULES (Dirk in #998 fixing #997).

  • XPtr tags are now preserved in as<> (Stephen Wade in #1003 fixing #986, plus Dirk in #1012).

  • A few more temporary allocations are now protected from garbage collection (Romain Francois in #1010, and Dirk in #1011).

• Changes in Rcpp Modules:

  • Improved initialization via explicit Rcpp:: prefix (Riccardo Porreca in #980).

• Changes in Rcpp Deployment:

  • A unit test for Rcpp Class exposure was updated to not fail under r-devel (Dirk in #1008 fixing #1006).

• Changes in Rcpp Documentation:

  • The Rcpp-modules vignette received a major review and edit (Riccardo Porreca in #982).

  • Minor whitespace alignments and edits were made in three vignettes following the new pinp release (Dirk).

  • New badges for DOI and CRAN and BioConductor reverse dependencies have been added to README.md (Dirk).

  • Vignettes are now included pre-made (Dirk in #1005 addressing #1004)).

  • The Rcpp FAQ has two new entries on 'no modules / no rtti' and exceptions across shared libraries (Dirk in #1009).

Changes in Rcpp version 1.0.2 (2019-07-20)

• Changes in Rcpp API:

  • Files in src/ are now consistentely lowercase (Dirk in #956).

  • The Rcpp 'API Version' is now accessible via getRcppVersion() (Dirk in #963).

• Changes in Rcpp Attributes:

  • The second END wrapper macro also gets UNPROTECT and a variable reference suppressing compiler warnings (Dirk in #953 fixing #951).

  • Default function arguments are parsed correctly (Pierrick Roger in #977 fixing #975)

• Changes in Rcpp Sugar:

  • Added decreasing parameter to sort_unique() (James Balamuta in #958 addressing #950).

• Changes in Rcpp Deployment:

  • Travis CI unit tests are now always running irrespective of the package version (Dirk in #954).

• Changes in Rcpp Documentation:

  • The Rcpp-modules vignette now covers the RCPP_EXPOSED_* macros, and the Rcpp-extending vignette references it (Ralf Stubner in #959 fixing #952).

Changes in Rcpp version 1.0.1 (2019-03-17)

• Changes in Rcpp API:

  • Subsetting is no longer limited by an integer range (William Nolan in #920 fixing #919).

  • Error messages from subsetting are now more informative (Qiang and Dirk).

  • Shelter increases count only on non-null objects (Dirk in #940 as suggested by Stepan Sindelar in #935).

  • AttributeProxy::set() and a few related setters get Shield<> to ensure rchk is happy (Romain in #947 fixing #946).

• Changes in Rcpp Attributes:

  • A new plugin was added for C++20 (Dirk in #927)

  • Fixed an issue where 'stale' symbols could become registered in RcppExports.cpp, leading to linker errors and other related issues (Kevin in #939 fixing #733 and #934).

  • The wrapper macro gets an UNPROTECT to ensure rchk is happy (Romain in #949) fixing #948).

• Changes in Rcpp Documentation:

  • Three small corrections were added in the 'Rcpp Quickref' vignette (Zhuoer Dong in #933 fixing #932).

  • The Rcpp-modules vignette now has documentation for .factory (Ralf Stubner in #938 fixing #937).

• Changes in Rcpp Deployment:

  • Travis CI again reports to CodeCov.io (Dirk and Ralf Stubner in #942 fixing #941).

Changes in Rcpp version 1.0.0 (2018-11-05)

• Happy tenth birthday to Rcpp, and hello release 1.0 !

• Changes in Rcpp API:

  • The empty destructor for the Date class was removed to please g++-9 (prerelease) and -Wdeprecated-copy (Dirk).

  • The constructor for NumericMatrix(not_init(n,k)) was corrected (Romain in #904, Dirk in #905, and also Romain in #908 fixing #907).

  • Rcpp::String no longer silently drops embedded NUL bytes in strings but throws new Rcpp exception embedded_nul_in_string. (Kevin in #917 fixing #916).

• Changes in Rcpp Deployment:

  • The Dockerfile for Continuous Integration sets the required test flag (for release versions) inside the container (Dirk).

  • Correct the R CMD check call to skip vignettes (Dirk).

• Changes in Rcpp Attributes:

  • A new [[Rcpp::init]] attribute allows function registration for running on package initialization (JJ in #903).

  • Sort the files scanned for attributes in the C locale for stable output across systems (JJ in #912).

• Changes in Rcpp Documentation:

  • The 'Rcpp Extending' vignette was corrected and refers to EXPOSED rather than EXPORTED (Ralf Stubner in #910).

  • The 'Unit test' vignette is no longer included (Dirk in #914).

Changes in Rcpp version 0.12.19 (2018-09-20)

• Changes in Rcpp API:

  • The no_init() accessor for vectors and matrices is now wrapped in Shield<>() to not trigger rchk warnings (Kirill Müller in #893 addressing #892).

  • STRICT_R_HEADERS will be defined twelve months from now; until then we protect it via RCPP_NO_STRICT_HEADERS which can then be used to avoid the definition; downstream maintainers are encouraged to update their packages as needed (Dirk in #900 beginning to address #898).

• Changes in Rcpp Attributes:

  • Added [[Rcpp::init]] attribute for registering C++ functions to run during package initialization (JJ in #903 addressing #902).

• Changes in Rcpp Modules:

  • Improved exposeClass functionality along with added test (Martin Lysy in #886 fixing #879).

• Changes in Rcpp Documentation:

  • Two typos were fixed in the Rcpp Sugar vignette (Patrick Miller in #895).

  • Several vignettes now use the collapse argument to show output in the corresponding code block.

• Changes in Rcpp Deployment:

  • The old LdFlags() build helper was marked as deprecated [but removed for release] (Dirk in #887).

  • Dockerfiles for continuous integration, standard deployment and 'plus sized' deployment are provided along with builds (Dirk in #894).

  • Travis CI now use the rcpp/ci container for tests (Dirk in #896).

Changes in Rcpp version 0.12.18 (2018-07-21)

• Changes in Rcpp API:

  • The StringProxy::operator== is now const correct (Romain in #855 fixing #854).

  • The Environment::new_child() is now const (Romain in #858 fixing #854).

  • Next eval codes now properly unwind (Lionel in the large and careful #859 fixing #807).

  • In debugging mode, more type information is shown on abort() (Jack Wasey in #860 and #882 fixing #857).

  • A new class was added which allow suspension of the RNG synchronisation to address an issue seen in RcppDE (Kevin in #862).

  • Evaluation calls now happen in the base environment (which may fix an issue seen between conflicted and some BioConductor packages) (Kevin in #863 fixing #861).

  • Call stack display on error can now be controlled more finely (Romain in #868).

  • The new Rcpp_fast_eval is used instead of Rcpp_eval though this still requires setting RCPP_USE_UNWIND_PROTECT before including Rcpp.h (Qiang Kou in #867 closing #866).

  • The Rcpp::unwindProtect() function extracts the unwinding from the Rcpp_fast_eval() function and makes it more generally available. (Lionel in #873 and #877).

  • The tm_gmtoff part is skipped on AIX too (#876).

• Changes in Rcpp Attributes:

  • The sourceCpp() function now evaluates R code in the correct local environment in which a function was compiled (Filip Schouwenaars in #852 and #869 fixing #851).

  • Filenames are now sorted in a case-insenstive way so that the RcppExports files are more stable across locales (Jack Wasey in #878).

• Changes in Rcpp Sugar:

  • The sugar functions min and max now recognise empty vectors (Dirk in #884 fixing #883).

Changes in Rcpp version 0.12.17 (2018-05-09)

• Changes in Rcpp API:

  • The random number Generator class no longer inherits from RNGScope (Kevin in #837 fixing #836).

  • A new class, SuspendRNGSynchronizationScope, can be created and used to ensure that calls to Rcpp functions do not attempt to call ::GetRNGstate() or ::PutRNGstate() for the duration of some code block.

  • A spurious parenthesis was removed to please gcc8 (Dirk fixing #841)

  • The optional Timer class header now undefines FALSE which was seen to have side-effects on some platforms (Romain in #847 fixing #846).

  • Optional StoragePolicy attributes now also work for string vectors (Romain in #850 fixing #849).

• Changes in Rcpp Documentation:

  • A few old typesetting conventions from the prior Rnw format have been corrected (Peter Hickey in #831; Joris Meys; Dirk)

  • Two internal links to the introduction published in JSS have been updated to the changed filename given the newer TAS introduction.

  • Some remaining backticks were replaced with straight quotes (Ralf Stubner in #845).

  • A citation to the Rcpp introducion in the The American Statistician has been added to the introductory and FAQ vignettes.

Changes in Rcpp version 0.12.16 (2018-03-08)

• Changes in Rcpp API:

  • Rcpp now sets and puts the RNG state upon each entry to an Rcpp function, ensuring that nested invocations of Rcpp functions manage the RNG state as expected (Kevin in #825 addressing #823).

  • The R::pythag wrapper has been commented out; the underlying function has been gone from R since 2.14.0, and ::hypot() (part of C99) is now used unconditionally for complex numbers (Dirk in #826).

  • The long long type can now be used on 64-bit Windows (Kevin in #811 and again in #829 addressing #804).

• Changes in Rcpp Attributes:

  • Code generated with cppFunction() now uses .Call() directly (Kirill Müller in #813 addressing #795).

• Changes in Rcpp Documentation:

  • The Rcpp FAQ vignette is now indexed as 'Rcpp-FAQ'; a stale Gmane reference was removed and entry for getting compilers under Conda was added.

  • The top-level README.md now has a Support section.

  • The Rcpp.bib reference file was refreshed to current versions.

Changes in Rcpp version 0.12.15 (2018-01-16)

• Changes in Rcpp API:

  • Calls from exception handling to Rf_warning() now correctly set an initial format string (Dirk in #777 fixing #776).

  • The 'new' Date and Datetime vectors now have is_na methods too. (Dirk in #783 fixing #781).

  • Protect more temporary SEXP objects produced by wrap (Kevin in #784).

  • Use public R APIs for new_env (Kevin in #785).

  • Evaluation of R code is now safer when compiled against R 3.5 (you also need to explicitly define RCPP_USE_UNWIND_PROTECT before including Rcpp.h). Longjumps of all kinds (condition catching, returns, restarts, debugger exit) are appropriately detected and handled, e.g. the C++ stack unwinds correctly (Lionel in #789). [ Committed but subsequently disabled in release 0.12.15 ]

  • The new function Rcpp_fast_eval() can be used for performance-sensitive evaluation of R code. Unlike Rcpp_eval(), it does not try to catch errors with tryEval in order to avoid the catching overhead. While this is safe thanks to the stack unwinding protection, this also means that R errors are not transformed to an Rcpp::exception. If you are relying on error rethrowing, you have to use the slower Rcpp_eval(). On old R versions Rcpp_fast_eval() falls back to Rcpp_eval() so it is safe to use against any versions of R (Lionel in #789). [ Committed but subsequently disabled in release 0.12.15 ]

  • Overly-clever checks for NA have been removed (Kevin in #790).

  • The included tinyformat has been updated to the current version, Rcpp-specific changes are now more isolated (Kirill in #791).

  • Overly picky fall-through warnings by gcc-7 regarding switch statements are now pre-empted (Kirill in #792).

  • Permit compilation on ANDROID (Kenny Bell in #796).

  • Improve support for NVCC, the CUDA compiler (Iñaki Ucar in #798 addressing #797).

  • Speed up tests for NA and NaN (Kirill and Dirk in #799 and #800).

  • Rearrange stack unwind test code, keep test disabled for now (Lionel in #801).

  • Further condition away protect unwind behind #define (Dirk in #802).

• Changes in Rcpp Attributes:

  • Addressed a missing Rcpp namespace prefix when generating a C++ interface (James Balamuta in #779).

• Changes in Rcpp Documentation:

  • The Rcpp FAQ now shows Rcpp::Rcpp.plugin.maker() and not the outdated ::: use applicable non-exported functions.

Changes in Rcpp version 0.12.14 (2017-11-17)

• Changes in Rcpp API:

  • New const iterators functions cbegin() and cend() added to MatrixRow as well (Dan Dillon in #750).

  • The Rostream object now contains a Buffer rather than allocating one (Kirill Müller in #763).

  • New DateVector and DatetimeVector classes are now the default fully deprecating the old classes as announced one year ago.

• Changes in Rcpp Package:

  • DESCRIPTION file now list doi information per CRAN suggestion.

• Changes in Rcpp Documentation:

  • Update CITATION file with doi information and PeerJ preprint.

Changes in Rcpp version 0.12.13 (2017-09-24)

• Changes in Rcpp API:

  • New const iterators functions cbegin() and cend() have been added to several vector and matrix classes (Dan Dillon and James Balamuta in #748) starting to address #741).

• Changes in Rcpp Modules:

  • Misplacement of one parenthesis in macro LOAD_RCPP_MODULE was corrected (Lei Yu in #737)

• Changes in Rcpp Documentation:

  • Rewrote the macOS sections to depend on official documentation due to large changes in the macOS toolchain. (James Balamuta in #742 addressing issue #682).

  • Added a new vignette ‘Rcpp-introduction’ based on new PeerJ preprint, renamed existing introduction to ‘Rcpp-jss-2011’.

  • Transitioned all vignettes to the 'pinp' RMarkdown template (James Balamuta and Dirk Eddelbuettel in #755 addressing issue #604).

  • Added an entry on running 'compileAttributes()' twice to the Rcpp-FAQ (##745).

Changes in Rcpp version 0.12.12 (2017-07-13)

• Changes in Rcpp API:

  • The tinyformat.h header now ends in a newline (#701).

  • Fixed rare protection error that occurred when fetching stack traces during the construction of an Rcpp exception (Kirill Müller in #706).

  • Compilation is now also possibly on Haiku-OS (Yo Gong in #708 addressing #707).

  • Dimension attributes are explicitly cast to int (Kirill Müller in #715).

  • Unused arguments are no longer declared (Kirill Müller in #716).

  • Visibility of exported functions is now supported via the R macro atttribute_visible (Jeroen Ooms in #720).

  • The no_init() constructor accepts R_xlen_t (Kirill Müller in #730).

  • Loop unrolling used R_xlen_t (Kirill Müller in #731).

  • Two unused-variables warnings are now avoided (Jeff Pollock in #732).

• Changes in Rcpp Attributes:

  • Execute tools::package_native_routine_registration_skeleton within package rather than current working directory (JJ in #697).

  • The R portion no longer uses dir.exists to no require R 3.2.0 or newer (Elias Pipping in #698).

  • Fix native registration for exports with name attribute (JJ in #703 addressing #702).

  • Automatically register init functions for Rcpp Modules (JJ in #705 addressing #704).

  • Add Shield around parameters in Rcpp::interfaces (JJ in #713 addressing #712).

  • Replace dot (".") with underscore ("_") in package names when generating native routine registrations (JJ in #722 addressing #721).

  • Generate C++ native routines with underscore ("_") prefix to avoid exporting when standard exportPattern is used in NAMESPACE (JJ in #725 addressing #723).

Changes in Rcpp version 0.12.11 (2017-05-20)

• Changes in Rcpp API:

  • Rcpp::exceptions can now be constructed without a call stack (Jim Hester in #663 addressing #664).

  • Somewhat spurious compiler messages under very verbose settings are now suppressed (Kirill Müller in #670, #671, #672, #687, #688, #691).

  • Refreshed the included tinyformat template library (James Balamuta in #674 addressing #673).

  • Added printf-like syntax support for exception classes and variadic templating for Rcpp::stop and Rcpp::warning (James Balamuta in #676).

  • Exception messages have been rewritten to provide additional information. (James Balamuta in #676 and #677 addressing #184).

  • One more instance of Rf_mkString is protected from garbage collection (Dirk in #686 addressing #685).

  • Two exception specification that are no longer tolerated by g++-7.1 or later were removed (Dirk in #690 addressing #689)

• Changes in Rcpp Documentation:

  • Added a Known Issues section to the Rcpp FAQ vignette (James Balamuta in #661 addressing #628, #563, #552, #460, #419, and #251).

• Changes in Rcpp Sugar:

  • Added sugar function trimws (Nathan Russell in #680 addressing #679).

• Changes in Rcpp Attributes:

  • Automatically generate native routine registrations (JJ in #694)

  • The plugins for C++11, C++14, C++17 now set the values R 3.4.0 or later expects; a plugin for C++98 was added (Dirk in #684 addressing #683).

• Changes in Rcpp support functions:

  • The Rcpp.package.skeleton() function now creates a package registration file provided R 3.4.0 or later is used (Dirk in #692)

Changes in Rcpp version 0.12.10 (2017-03-17)

• Changes in Rcpp API:

  • Added new size attribute aliases for number of rows and columns in DataFrame (James Balamuta in #638 addressing #630).

  • Fixed single-character handling in Rstreambuf (Iñaki Ucar in #649 addressing #647).

  • XPtr gains a parameter finalizeOnExit to enable running the finalizer when R quits (Jeroen Ooms in #656 addressing #655).

• Changes in Rcpp Sugar:

  • Fixed sugar functions upper_tri() and lower_tri() (Nathan Russell in #642 addressing #641).

  • The algorithm.h file now accomodates the Intel compiler (Dirk in #643 and Dan in #645 addressing issue #640).

• Changes in Rcpp Attributes:

  • The C++17 standard is supported with a new plugin (used eg for g++-6.2).

• Changes in Rcpp Documentation:

  • An overdue explanation of how C++11, C++14, and C++17 can be used was added to the Rcpp FAQ.

Changes in Rcpp version 0.12.9 (2017-01-14)

• Changes in Rcpp API:

  • The exception stack message is now correctly demangled on all compiler versions (Jim Hester in #598)

  • Date and Datetime object and vector now have format methods and operator<< support (#599).

  • The size operator in Matrix is explicitly referenced avoiding a g++-6 issues (#607 fixing #605).

  • The underlying date calculation code was updated (#621, #623).

  • Addressed improper diagonal fill for non-symmetric matrices (James Balamuta in #622 addressing #619)

• Changes in Rcpp Sugar:

  • Added new Sugar function sample() (Nathan Russell in #610 and #616).

  • Added new Sugar function Arg() (James Balamuta in #626 addressing #625).

• Changes in Rcpp unit tests

  • Added Environment::find unit tests and an Environment::get(Symbol) test (James Balamuta in #595 addressing issue #594).

  • Added diagonal matrix fill tests (James Balamuta in #622 addressing #619)

• Changes in Rcpp Documentation:

  • Exposed pointers macros were included in the Rcpp Extending vignette (MathurinD; James Balamuta in #592 addressing #418).

  • The file Rcpp.bib move to directory bib which is guaranteed to be present (#631).

• Changes in Rcpp build system

  • Travis CI now also calls covr for coverage analysis (Jim Hester in PR #591)

Changes in Rcpp version 0.12.8 (2016-11-16)

• Changes in Rcpp API:

  • String and vector elements now use extended R_xlen_t indices (Qiang in PR #560)

  • Hashing functions now return unsigned int (Qiang in PR #561)

  • Added static methods eye(), ones(), and zeros() for select matrix types (Nathan Russell in PR #569)

  • The exception call stack is again correctly reported; print methods and tests added too (Jim Hester in PR #582 fixing #579)

  • Variatic macros no longer use a GNU extensions (Nathan in PR #575)

  • Hash index functions were standardized on returning unsigned integers (Also PR #575)

• Changes in Rcpp Sugar:

  • Added new Sugar functions rowSums(), colSums(), rowMeans(), colMeans() (PR #551 by Nathan Russell fixing #549)

  • Range Sugar now used R_xlen_t type for start/end (PR #568 by Qiang Kou)

  • Defining RCPP_NO_SUGAR no longer breaks the build. (PR #585 by Daniel C. Dillon)

• Changes in Rcpp unit tests

  • A test for expression vectors was corrected.

  • The constructor test for datetime vectors reflects the new classes which treats Inf correctly (and still as a non-finite value)

• Changes in Rcpp Attributes

  • An 'empty' return was corrected (PR #589 fixing issue #588, and with thanks to Duncan Murdoch for the heads-up)

• Updated Date and Datetime vector classes:

  • The DateVector and DatetimeVector classes were renamed with a prefix old; they are currently typedef'ed to the existing name (#557)

  • New variants newDateVector and newDatetimeVector were added based on NumericVector (also #557, #577, #581, #587)

  • By defining RCPP_NEW_DATE_DATETIME_VECTORS the new classes can activated. We intend to make the new classes the default no sooner than twelve months from this release.

  • The capabilities() function can also be used for presence of this feature

Changes in Rcpp version 0.12.7 (2016-09-04)

• Changes in Rcpp API:

  • The NORET macro is now defined if it was not already defined by R itself (Kevin fixing issue #512).

  • Environment functions get() & find() now accept a Symbol (James Balamuta in #513 addressing issue #326).

  • Several uses of Rf_eval were replaced by the preferred Rcpp::Rcpp_eval (Qiang in PR #523 closing #498).

  • Improved Autogeneration Warning for RcppExports (James Balamuta in #528 addressing issue #526).

  • Fixed invalid C++ prefix identifiers in auto-generated code (James Balamuta in #528 and #531 addressing issue #387; Simon Dirmeier in #548).

  • String constructors now set default UTF-8 encoding (Qiang Kou in #529 fixing #263).

  • Add variadic variants of the RCPP_RETURN_VECTOR and RCPP_RETURN_MATRIX macro when C++11 compiler used (Artem Klevtsov in #537 fixing #38).

• Changes in Rcpp build system

  • Travis CI is now driven via run.sh from our fork, and deploys all packages as .deb binaries using our PPA where needed (Dirk in #540 addressing issue #517).

• Changes in Rcpp unit tests

  • New unit tests for random number generators the R namespace which call the standalone Rmath library. (James Balamuta in #514 addressing issue #28).

• Changes in Rcpp Examples:

  • Examples that used cxxfunction() from the inline package have been rewritten to use either sourceCpp() or cppFunction() (James Balamuta in #541, #535, #534, and #532 addressing issue #56).

Changes in Rcpp version 0.12.6 (2016-07-18)

• Changes in Rcpp API:

  • The long long data type is used only if it is available, to avoid compiler warnings (Kirill Müller in #488).

  • The compiler is made aware that stop() never returns, to improve code path analysis (Kirill Müller in #487 addressing issue #486).

  • String replacement was corrected (Qiang in #479 following mailing list bug report by Masaki Tsuda)

  • Allow for UTF-8 encoding in error messages via RCPP_USING_UTF8_ERROR_STRING macro (Qin Wenfeng in #493)

  • The R function Rf_warningcall is now provided as well (as usual without leading Rf_) (#497 fixing #495)

• Changes in Rcpp Sugar:

  • Const-ness of min and max functions has been corrected. (Dan Dillon in PR #478 fixing issue #477).

  • Ambiguities for matrix/vector and scalar operations have been fixed (Dan Dillon in PR #476 fixing issue #475).

  • New algorithm header using iterator-based approach for vectorized functions (Dan in PR #481 revisiting PR #428 and addressing issue #426, with futher work by Kirill in PR #488 and Nathan in #503 fixing issue #502).

  • The na_omit() function is now faster for vectors without NA values (Artem Klevtsov in PR #492)

• Changes in Rcpp Attributes:

  • Add cacheDir argument to sourceCpp() to enable caching of shared libraries across R sessions (JJ in #504).

  • Code generation now deals correctly which packages containing a dot in their name (Qiang in #501 fixing #500).

• Changes in Rcpp Documentation:

  • A section on default parameters was added to the Rcpp FAQ vignette (James Balamuta in #505 fixing #418).

  • The Rcpp-attributes vignette is now mentioned more prominently in question one of the Rcpp FAQ vignette.

  • The Rcpp Quick Reference vignette received a facelift with new sections on Rcpp attributes and plugins begin added. (James Balamuta in #509 fixing #484).

  • The bib file was updated with respect to the recent JSS publication for RProtoBuf.

Changes in Rcpp version 0.12.5 (2016-05-14)

• Changes in Rcpp API:

  • The checks for different C library implementations now also check for Musl used by Alpine Linux (Sergio Marques in PR #449).

  • Rcpp::Nullable works better with Rcpp::String (Dan Dillon in PR #453).

• Changes in Rcpp Attributes:

  • R 3.3.0 Windows with Rtools 3.3 is now supported (Qin Wenfeng in PR #451).

  • Correct handling of dependent file paths on Windows (use winslash = "/").

• Changes in Rcpp Modules:

  • An apparent race condition in Module loading seen with R 3.3.0 was fixed (Ben Goodrich in #461 fixing #458).

  • The (older) loadRcppModules() is now deprecated in favour of loadModule() introduced around R 2.15.1 and Rcpp 0.9.11 (PR #470).

• Changes in Rcpp support functions:

  • The Rcpp.package.skeleton() function was again updated in order to create a DESCRIPTION file which passes R CMD check without notes. warnings, or error under R-release and R-devel (PR #471).

  • A new function compilerCheck can test for minimal g++ versions (PR #474).

Changes in Rcpp version 0.12.4 (2016-03-22)

• Changes in Rcpp API:

  • New accessors as() and clone() were added to the Nullable class (Dan in PR #423 closing #421)

  • The Nullable<>::operator SEXP() and Nullable<>::get() now also work for const objects (Kirill Müller in PR #417).

  • A subsetting error was fixed (Qiang via #432 closing #431).

• Changes in Rcpp Sugar:

  • Added new Sugar function median() (Nathan in PR #425 closing #424)

  • Added new Sugar function cbind() (Nathan in PR #447 closing #407)

• Changes in Rcpp Attributes:

  • A plugin for C++14 was added (Dan in PR #427)

• Changes in Rcpp Documentation:

  • An entry was added to the Rcpp-FAQ vignette describing the required packages for vignette building (#422).

  • Use on OS X was further detailed (James Balamuta in #433 with further review by Bob Rudis).

  • An entry was added concerning the hard-code limit of arguments to some constructor and function (cf #435).

  • The Rcpp-FAQ vignette now contains a table of content.

  • Typos and indentation were corrected in the Rcpp Sugar vignette (#445 by Colin Gillespie).

Changes in Rcpp version 0.12.3 (2016-01-10)

• Changes in Rcpp API:

  • Const iterators now CharacterVector now behave like regular iterators (PR #404 by Dan fixing #362).

  • Math operators between matrix and scalars type have been added (PR #406 by Qiang fixing #365).

  • A missing std::hash function interface for Rcpp::String has been addded (PR #408 by Qiang fixing #84).

• Changes in Rcpp Attributes:

  • Avoid invalid function names when generating C++ interfaces (PR #403 by JJ fixing #402).

  • Insert additional space around & in function interface (PR #400 by Kazuki Fukui fixing #278).

• Changes in Rcpp Modules:

  • The copy constructor now initialized the base class (PR #411 by Joshua Pritikin fixing #410)

• Changes in Rcpp Repository:

  • Added a file Contributing.md providing some points to potential contributors (PR #414 closing issue #413)

Changes in Rcpp version 0.12.2 (2015-11-14)

• Changes in Rcpp API:

  • Correct return type in product of matrix dimensions (PR #374 by Florian)

  • Before creating a single String object from a SEXP, ensure that it is from a vector of length one (PR #376 by Dirk, fixing #375).

  • No longer use STRING_ELT as a left-hand side, thanks to a heads-up by Luke Tierney (PR #378 by Dirk, fixing #377).

  • Rcpp Module objects are now checked more carefully (PR #381 by Tianqi, fixing #380)

  • An overflow in Matrix column indexing was corrected (PR #390 by Qiang, fixing a bug reported by Allessandro on the list)

  • Nullable types can now be assigned R_NilValue in function signatures. (PR #395 by Dan, fixing issue #394)

  • operator<<() now always shows decimal points (PR #396 by Dan)

  • Matrix classes now have a transpose() function (PR #397 by Dirk fixing #383)

  • operator<<() for complex types was added (PRs #398 by Qiang and #399 by Dirk, fixing #187)

• Changes in Rcpp Attributes:

  • Enable export of C++ interface for functions that return void.

• Changes in Rcpp Sugar:

  • Added new Sugar function cummin(), cummax(), cumprod() (PR #389 by Nathan Russell fixing #388)

  • Enabled sugar math operations for subsets; e.g. x[y] + x[z]. (PR #393 by Kevin and Qiang, implementing #392)

• Changes in Rcpp Documentation:

  • The NEWS file now links to GitHub issue tickets and pull requests.

  • The Rcpp.bib file with bibliographic references was updated.

Changes in Rcpp version 0.12.1 (2015-09-10)

• Changes in Rcpp API:

  • Correct use of WIN32 instead of _WIN32 to please Windows 10

  • Add an assignment operator to DimNameProxy (PR #339 by Florian)

  • Add vector and matrix accessors .at() with bounds checking (PR #342 by Florian)

  • Correct character vector conversion from single char (PR #344 by Florian fixing issue #343)

  • Correct on use of R_xlen_t back to size_t (PR #348 by Romain)

  • Correct subsetting code to allow for single assignment (PR #349 by Florian)

  • Enable subset assignment on left and righ-hand side (PR #353 by Qiang, fixing issue #345)

  • Refreshed to included tinyformat template library (PR #357 by Dirk, issue #356)

  • Add operator<<() for vectors and matrices (PR #361 by Dan fixing issue #239)

  • Make String and String_Proxy objects comparable (PR #366 and PR #372 by Dan, fixing issue #191)

  • Add a new class Nullable for objects which may be NULL (PR #368 by Dirk and Dan, fixing issue #363)

  • Correct creation and access of large matrices (PR #370 by Florian, fixing issue #369)

• Changes in Rcpp Attributes:

  • Correctly reset directory in case of no-rebuilding but Windows code (PR #335 by Dirk)

• Changes in Rcpp Modules:

  • We no longer define multiple Modules objects named World in the unit tests with was seen to have a bad effect with R 3.2.2 or later (PR #351 by Dirk fixing issue #350).

  • Applied patch by Kurt Hornik which improves how Rcpp loads Modules (PR #353 by Dirk)

• Changes in Rcpp Documentation:

  • The Rcpp.bib file with bibliographic references was updated.

Changes in Rcpp version 0.12.0 (2015-07-24)

• Changes in Rcpp API:

  • Rcpp_eval() no longer uses R_ToplevelExec when evaluating R expressions; this should resolve errors where calling handlers (e.g. through suppressMessages()) were not properly respected.

  • All internal length variables have been changed from R_len_t to R_xlen_t to support vectors longer than 2^31-1 elements (via PR #303 by Qiang Kou).

  • The sugar function sapply now supports lambda functions (addressing #213 thanks to Matt Dziubinski)

  • The var sugar function now uses a more robust two-pass method, supports complex numbers, with new unit tests added (via PR #320 by Matt Dziubinski)

  • String constructors now allow encodings (via PR #310 by Qiang Kou)

  • String objects are preserving the underlying SEXP objects better, and are more careful about initializations (via PRs #322 and #329 by Qiang Kou)

  • DataFrame constructors are now a little more careful (via PR #301 by Romain Francois)

  • For R 3.2.0 or newer, Rf_installChar() is used instead of Rf_install(CHAR()) (via PR #332).

• Changes in Rcpp Attributes:

  • Use more robust method of ensuring unique paths for generated shared libraries.

  • The evalCpp function now also supports the plugins argument.

  • Correctly handle signature termination characters ('{' or ';') contained in quotes.

• Changes in Rcpp Documentation:

  • The Rcpp-FAQ vignette was once again updated with respect to OS X issues and Fortran libraries needed for e.g. RcppArmadillo.

  • The included Rcpp.bib bibtex file (which is also used by other Rcpp* packages) was updated with respect to its CRAN references.

Changes in Rcpp version 0.11.6 (2015-05-01)

• Changes in Rcpp API:

  • The unwinding of exceptions was refined to protect against inadvertent memory leaks.

  • Header files now try even harder not to let macro definitions leak.

  • Matrices have a new default constructor for zero-by-zero dimension matrices (via a pull request by Dmitrii Meleshko).

  • A new empty() string constructor was added (via another pull request).

  • Better support for Vectors with a storage policy different from the default, i.e. NoProtectStorage, was added.

• Changes in Rcpp Attributes:

  • Rtools 3.3 is now supported.

Changes in Rcpp version 0.11.5 (2015-03-04)

• Changes in Rcpp API:

  • An error handler for tinyformat was defined to prevent the assert() macro from spilling.

  • The Rcpp::warning function was added as a wrapper for Rf_warning.

  • The XPtr class was extended with new checked_get and release functions as well as improved behavior (throw an exception rather than crash) when a NULL external pointer is dereferenced.

  • R code is evaluated within an R_toplevelExec block to prevent user interrupts from bypassing C++ destructors on the stack.

  • The Rcpp::Environment constructor can now use a supplied parent environment.

  • The Rcpp::Function constructor can now use a supplied environment or namespace.

  • The attributes_hidden macro from R is used to shield internal functions; the R_ext/Visibility.h header is now included as well.

  • A Rcpp::print function was added as a wrapper around Rf_PrintValue.

• Changes in Rcpp Attributes:

  • The pkg_types.h file is now included in RcppExports.cpp if it is present in either the inst/include or src.

  • sourceCpp was modified to allow includes of local files (e.g. #include "foo.hpp"). Implementation files (*.cc; *.cpp) corresponding to local includes are also automatically built if they exist.

  • The generated attributes code was simplified with respect to RNGScope and now uses RObject and its destructor rather than SEXP protect/unprotect.

  • Support addition of the rng parameter in Rcpp::export to suppress the otherwise automatic inclusion of RNGScope in generated code.

  • Attributes code was made more robust and can e.g. no longer recurse.

  • Version 3.2 of the Rtools is now correctly detected as well.

  • Allow 'R' to come immediately after '***' for defining embedded R code chunks in sourceCpp.

  • The attributes vignette has been updated with documentation on new features added over the past several releases.

• Changes in Rcpp tests:

  • On Travis CI, all build dependencies are installed as binary .deb packages resulting in faster tests.

Changes in Rcpp version 0.11.4 (2015-01-20)

• Changes in Rcpp API:

  • The ListOf<T> class gains the .attr and .names methods common to other Rcpp vectors.

  • The [dpq]nbinom_mu() scalar functions are now available via the R:: namespace when R 3.1.2 or newer is used.

  • Add an additional test for AIX before attempting to include execinfo.h.

  • Rcpp::stop now supports improved printf-like syntax using the small tinyformat header-only library (following a similar implementation in Rcpp11)

  • Pairlist objects are now protected via an additional Shield<> as suggested by Martin Morgan on the rcpp-devel list.

  • Sorting is now prohibited at compile time for objects of type List, RawVector and ExpressionVector.

  • Vectors now have a Vector::const\_iterator that is 'const correct' thanks to fix by Romain following a bug report in rcpp-devel by Martyn Plummer.

  • The mean() sugar function now uses a more robust two-pass method, and new unit tests for mean() were added at the same time.

  • The mean() and var() functions now support all core vector types.

  • The setequal() sugar function has been corrected via suggestion by Qiang Kou following a bug report by Søren Højsgaard.

  • The macros major, minor, and makedev no longer leak in from the (Linux) system header sys/sysmacros.h.

  • The push_front() string function was corrected.

• Changes in Rcpp Attributes:

  • Only look for plugins in the package's namespace (rather than entire search path).

  • Also scan header files for definitions of functions to be considerd by Attributes.

  • Correct the regular expression for source files which are scanned.

• Changes in Rcpp unit tests

  • Added a new binary test which will load a pre-built package to ensure that the Application Binary Interface (ABI) did not change; this test will (mostly or) only run at Travis where we have reasonable control over the platform running the test and can provide a binary.

  • New unit tests for sugar functions mean, setequal and var were added as noted above.

• Changes in Rcpp Examples:

  • For the (old) examples ConvolveBenchmarks and OpenMP, the respective Makefile was renamed to GNUmakefile to please R CMD check as well as the CRAN Maintainers.

Changes in Rcpp version 0.11.3 (2014-09-27)

• Changes in Rcpp API:

  • The deprecation of RCPP_FUNCTION_* which was announced with release 0.10.5 last year is proceeding as planned, and the file macros/preprocessor_generated.h has been removed.

  • Timer no longer records time between steps, but times from the origin. It also gains a get_timers(int) methods that creates a vector of Timer that have the same origin. This is modelled on the Rcpp11 implementation and is more useful for situations where we use timers in several threads. Timer also gains a constructor taking a nanotime_t to use as its origin, and a origin method. This can be useful for situations where the number of threads is not known in advance but we still want to track what goes on in each thread.

  • A cast to bool was removed in the vector proxy code as inconsistent behaviour between clang and g++ compilations was noticed.

  • A missing update(SEXP) method was added thanks to pull request by Omar Andres Zapata Mesa.

  • A proxy for DimNames was added.

  • A no_init option was added for Matrices and Vectors.

  • The InternalFunction class was updated to work with std::function (provided a suitable C++11 compiler is available) via a pull request by Christian Authmann.

  • A new_env() function was added to Environment.h

  • The return value of range eraser for Vectors was fixed in a pull request by Yixuan Qiu.

• Changes in Rcpp Sugar:

  • In ifelse(), the returned NA type was corrected for operator[].

• Changes in Rcpp Attributes:

  • Include LinkingTo in DESCRIPTION fields scanned to confirm that C++ dependencies are referenced by package.

  • Add dryRun parameter to sourceCpp.

  • Corrected issue with relative path and R chunk use for sourceCpp.

• Changes in Rcpp Documentation:

  • The Rcpp-FAQ vignette was updated with respect to OS X issues.

  • A new entry in the Rcpp-FAQ clarifies the use of licenses.

  • Vignettes build results no longer copied to /tmp to please CRAN.

  • The Description in DESCRIPTION has been shortened.

• Changes in Rcpp support functions:

  • The Rcpp.package.skeleton() function will now use pkgKitten package, if available, to create a package which passes R CMD check without warnings. A new Suggests: has been added for pkgKitten.

  • The modules=TRUE case for Rcpp.package.skeleton() has been improved and now runs without complaints from R CMD check as well.

• Changes in Rcpp unit test functions:

  • Functions from the RUnit package are now prefixed with RUnit::

  • The testRcppModule and testRcppClass sample packages now pass R CMD check --as-cran cleanly with NOTES or WARNINGS

Changes in Rcpp version 0.11.2 (2014-06-06)

• Changes in Rcpp API:

  • Implicit conversions, e.g. between NumericVector and IntegerVector, will now give warnings if you use \#define RCPP_WARN_ON_COERCE before including the Rcpp headers.

  • Templated List containers, ListOf<T>, have been introduced. When subsetting such containers, the return is assumed to be of type T, allowing code such as ListOf<NumericVector> x; NumericVector y = x[0] + x[1] + x[2].

  • In a number of instances, returned results are protected and/or cast more carefully.

• Changes in Rcpp Attributes

  • Trailing line comments are now stripped by the attributes parser. This allows the parser to handle C++ source files containing comments inline with function arguments.

  • The USE_CXX1X environment variable is now defined by the cpp11 plugin when R >= 3.1. Two additional plugins have been added for use with C++0x (eg when using g++ 4.6.* as on Windows) as well as C++1y for compilers beginning to support the next revision of the standard; additional fallback is provided for Windows.

  • compileAttributes() now also considers Imports: which may suppress a warning when running Rcpp.package.skeleton().

Changes in Rcpp version 0.11.1 (2014-03-13)

• Changes in Rcpp API:

  • Preserve backwards compatibility with Rcpp 0.10.* by allowing RObject extraction from vectors (or lists) of Rcpp objects

  • Add missing default constructor to Reference class that was omitted in the header-only rewrite

  • Fixes for NA and NaN handling of the IndexHash class, as well as the vector .sort() method. These fixes ensure that sugar functions depending on IndexHash (i.e. unique(), sort_unique(), match()) will now properly handle NA and NaN values for numeric vectors.

  • DataFrame::nrows now more accurately mimics R's internal behavior (checks the row.names attribute)

  • Numerous changes to permit compilation on the Solaris OS

  • Rcpp vectors gain a subsetting method – it is now possible to subset an Rcpp vector using CharacterVectors (subset by name), LogicalVectors (logical subsetting), and IntegerVectors (0-based index subsetting). Such subsetting will also work with Rcpp sugar expressions, enabling expressions such as x[ x > 0].

  • Comma initialization (e.g. CharacterVector x = "a", "b", "c";, has been disabled, as it causes problems with the behavior of the = operator with Rcpp::Lists. Users who want to re-enable this functionality can use #define RCPP_COMMA_INITIALIZATION, but be aware of the above caveat. The more verbose CharacterVector x = CharacterVector::create("a", "b", "c") is preferred.

• Changes in Rcpp Attributes

  • Fix issue preventing packages with Rcpp::interfaces attribute from compiling.

  • Fix behavior with attributes parsing of ::create for default arguments, and also allow constructors of a given size (e.g. NumericVector v = NumericVector(10)) gives a default value of numeric(10) at the R level). Also make NAs preserve type when exported to R (e.g. NA_STRING as a default argument maps to NA_character_ at the R level)

• Changes in Rcpp modules

  • Corrected the un_pointer implementation for object

Changes in Rcpp version 0.11.0 (2014-02-02)

• Changes in Rcpp API:

  • Functions provided/used by Rcpp are now registered with R and instantiated by client package alleviating the new for explicit linking against libRcpp which is therefore no longer created.

  • Updated the Rcpp.package.skeleton() function accordingly.

  • New class StretchyList for pair lists with fast addition of elements at the front and back. This abstracts the 3 functions NewList, GrowList and Insert used in various packages and in parsers in R.

  • The function dnt, pnt, qnt sugar functions were incorrectly expanding to the no-degree-of-freedoms variant.

  • Unit tests for pnt were added.

  • The sugar table function did not handle NAs and NaNs properly for numeric vectors. Fixed and tests added.

  • The internal coercion mechanism mapping numerics to strings has been updated to better match R (specifically with Inf, -Inf, and NaN.)

  • Applied two bug fixes to Vector sort() and RObject definition spotted and corrected by Kevin Ushey

  • New checkUserInterrupt() function that provides a C++ friendly implementation of R_CheckUserInterrupt.

• Changes in Rcpp attributes:

  • Embedded R code chunks in sourceCpp are now executed within the working directory of the C++ source file.

  • Embedded R code chunks in sourceCpp can now be disabled.

• Changes in Rcpp documentation:

  • The Rcpp-FAQ and Rcpp-package vignettes have been updated and expanded.

  • Vignettes are now typeset with grey background for code boxes.

  • The bibtex reference file has been update to reflexct current package versions.

• Changes in Rcpp unit tests:

  • The file tests/doRUnit.R was rewritten following the pattern deployed in RProtoBuf which is due to Murray Stokely

  • The function test() was rewritten; it provides an easy entry point to running unit tests of the installed package

Changes in Rcpp version 0.10.6 (2013-10-27)

• Changes in Rcpp API:

  • The function exposeClass takes a description of the constructors, fields and methods to be exposed from a C++ class, and writes C++ and R files in the package. Inherited classes can be dealt with, but require data type information. This approach avoids hand-coding module files.

  • Two missing is<>() templates for CharacterVector and CharacterMatrix have been added, and some tests for is_na() and is_finite() have been corrected thanks to Thomas Tse.

• Changes in R code:

  • Export linking helper function LdFlags as well as RcppLdFlags.

  • Function Rcpp.package.skeleton() no longer passes a namespace argument on to package.skeleton()

• Changes in R setup:

  • Raise requirement for R itself to be version 3.0.0 or later as needed by the vignette processing

• Changes in Rcpp attributes:

  • sourceCpp now correctly binds to Rtools 3.0 and 3.1

Changes in Rcpp version 0.10.5 (2013-09-28)

• Changes in R code:

  • New R function demangle that calls the DEMANGLE macro.

  • New R function sizeof to query the byte size of a type. This returns an object of S3 class bytes that has a print method showing bytes and bits.

• Changes in Rcpp API:

  • Add defined(__sun) to lists of operating systems to test for when checking for lack of backtrace() needed for stack traces.

  • as<T*>, as<const T*>, as<T&> and as<const T&> are now supported, when T is a class exposed by modules, i.e. with RCPP_EXPOSED_CLASS

  • DoubleVector as been added as an alias to NumericVector

  • New template function is<T> to identify if an R object can be seen as a T. For example is<DataFrame>(x). This is a building block for more expressive dispatch in various places (modules and attributes functions).

  • wrap can now handle more types, i.e. types that iterate over std::pair<const KEY, VALUE> where KEY can be converted to a String and VALUE is either a primitive type (int, double) or a type that wraps. Examples :

    • std::map<int, double> : we can make a String from an int, and double is primitive

    • boost::unordered_map<double, std::vector<double> >: we can make a String from a double and std::vector<double> can wrap itself

    Other examples of this are included at the end of the wrap unit test file (runit.wrap.R and wrap.cpp).

  • wrap now handles containers of classes handled by modules. e.g. if you expose a class Foo via modules, then you can wrap vector<Foo>, ... An example is included in the wrap unit test file

  • RcppLdFlags(), often used in Makevars files of packages using Rcpp, is now exported from the package namespace.

• Changes in Attributes:

  • Objects exported by a module (i.e. by a RCPP_MODULE call in a file that is processed by sourceCpp) are now directly available in the environment. We used to make the module object available, which was less useful.

  • A plugin for openmp has been added to support use of OpenMP.

  • Rcpp::export now takes advantage of the more flexible as<>, handling constness and referenceness of the input types. For users, it means that for the parameters of function exported by modules, we can now use references, pointers and const versions of them. The file Module.cpp file has an example.

  • No longer call non-exported functions from the tools package

  • No longer search the inline package as a fallback when loading plugins for the the Rcpp::plugins attribute.

• Changes in Modules:

  • We can now expose functions and methods that take T& or const T& as arguments. In these situations objects are no longer copied as they used to be.

• Changes in sugar:

  • is_na supports classes DatetimeVector and DateVector

• Changes in Rcpp documentation:

  • The vignettes have been moved from inst/doc/ to the vignettes directory which is now preferred.

  • The appearance of the vignettes has been refreshed by switching to the Bistream Charter font, and microtype package.

• Deprecation of RCPP_FUNCTION_*:

  • The macros from the preprocessor_generated.h file have been deprecated. They are still available, but they print a message in addition to their expected behavior.

  • The macros will be permanently removed in the first Rcpp release after July 2014.

  • Users of these macros should start replacing them with more up-to-date code, such as using 'Rcpp attributes' or 'Rcpp modules'.

Changes in Rcpp version 0.10.4 (2013-06-23)

• Changes in R code: None beyond those detailed for Rcpp Attributes

• Changes in Rcpp attributes:

  • Fixed problem whereby the interaction between the gc and the RNGScope destructor could cause a crash.

  • Don't include package header file in generated C++ interface header files.

  • Lookup plugins in inline package if they aren't found within the Rcpp package.

  • Disallow compilation for files that don't have extensions supported by R CMD SHLIB

• Changes in Rcpp API:

  • The DataFrame::create set of functions has been reworked to just use List::create and feed to the DataFrame constructor

  • The operator-() semantics for Date and Datetime are now more inline with standard C++ behaviour; with thanks to Robin Girard for the report.

  • RNGScope counter now uses unsigned long rather than int.

  • Vector<*>::erase(iterator, iterator) was fixed. Now it does not remove the element pointed by last (similar to what is done on stl types and what was intended initially). Reported on Rcpp-devel by Toni Giorgino.

  • Added equality operator between elements of CharacterVectors.

• Changes in Rcpp sugar:

  • New function na_omit based on a StackOverflow thread

  • New function is_finite and is_infinite that reproduces the behavior of R's is.finite and is.infinite functions

• Changes in Rcpp build tools:

  • Fix by Martyn Plummer for Solaris in handling of SingleLogicalResult.

  • The src/Makevars file can now optionally override the path for /usr/bin/install_name_tool which is used on OS X.

  • Vignettes are trying harder not to be built in parallel.

• Changes in Rcpp documentation:

  • Updated the bibliography in Rcpp.bib (which is also sourced by packages using Rcpp).

  • Updated the THANKS file.

• Planned Deprecation of RCPP_FUNCTION_*:

  • The set of macros RCPP_FUNCTION_ etc ... from the preprocessor_generated.h file will be deprecated in the next version of Rcpp, i.e they will still be available but will generate some warning in addition to their expected behavior.

  • In the first release that is at least 12 months after this announcement, the macros will be removed from Rcpp.

  • Users of these macros (if there are any) should start replacing them with more up to date code, such as using Rcpp attributes or Rcpp modules.

Changes in Rcpp version 0.10.3 (2013-03-23)

• 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 version 0.10.2 (2012-12-21)

• 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 version 0.10.1 (2012-11-26)

• 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

Changes in Rcpp version 0.10.0 (2012-11-13)

• 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.

Changes in Rcpp version 0.9.15 (2012-10-13)

• 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

Changes in Rcpp version 0.9.14 (2012-09-30)

• 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

Changes in Rcpp version 0.9.13 (2012-06-28)

• 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

Changes in Rcpp version 0.9.12 (2012-06-23)

• 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

Changes in Rcpp version 0.9.11 (2012-06-22)

• 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

Changes in Rcpp version 0.9.10 (2012-02-16)

• 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

Changes in Rcpp version 0.9.9 (2012-12-25)

• 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

Changes in Rcpp version 0.9.8 (2011-12-21)

• 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

Changes in Rcpp version 0.9.7 (2011-09-29)

• 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

Changes in Rcpp version 0.9.6 (2011-07-26)

• 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

Changes in Rcpp version 0.9.5 (2011-07-05)

• 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

Changes in Rcpp version 0.9.4 (2011-04-12)

• 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

Changes in Rcpp version 0.9.3 (2011-04-05)

• 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

Changes in Rcpp version 0.9.2 (2011-02-23)

• 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

Changes in Rcpp version 0.9.1 (2011-02-14)

• 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

Changes in Rcpp version 0.9.0 (2010-12-19)

• 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.

Changes in Rcpp version 0.8.9 (2010-11-27)

• 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

Changes in Rcpp version 0.8.8 (2010-11-01)

• 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

Changes in Rcpp version 0.8.7 (2010-10-15)

• 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

Changes in Rcpp version 0.8.6 (2010-09-09)

• 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

Changes in Rcpp version 0.8.5 (2010-07-25)

• 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

Changes in Rcpp version 0.8.4 (2010-07-09)

• 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

Changes in Rcpp version 0.8.3 (2010-06-27)

• 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

Changes in Rcpp version 0.8.2 (2010-06-09)

• Bug-fix release for suncc compiler with thanks to Brian Ripley for additional testing.

Changes in Rcpp version 0.8.1 (2010-06-08)

• 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

Changes in Rcpp version 0.8.0 (2010-05-17)

• 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

Changes in Rcpp version 0.7.12 (2010-04-16)

• Undo shQuote() to protect Windows path names (which may contain spaces) as backticks use is still broken; use of $(shell ...) works

Changes in Rcpp version 0.7.11 (2010-03-26)

• 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

Changes in Rcpp version 0.7.10 (2010-03-15)

• 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)

Changes in Rcpp version 0.7.9 (2010-03-12)

• 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.

Changes in Rcpp version 0.7.8 (2010-03-09)

• 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

Changes in Rcpp version 0.7.7 (2010-02-14)

• 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.

Changes in Rcpp version 0.7.6 (2010-02-12)

• 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>

Changes in Rcpp version 0.7.5 (2010-02-08)

• 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)

Changes in Rcpp version 0.7.4 (2010-01-30)

• 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

Changes in Rcpp version 0.7.3 (2010-01-21)

• 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.

Changes in Rcpp version 0.7.2 (2010-01-12)

• 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.

Changes in Rcpp version 0.7.1 (2010-01-02)

• 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

Changes in Rcpp version 0.7.0 (2009-12-19)

• 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

Changes in Rcpp version 0.6.8 (2009-11-19)

• 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

Changes in Rcpp version 0.6.7 (2009-11-08)

• 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

Changes in Rcpp version 0.6.6 (2009-08-03)

• Updated Doxygen documentation

• RcppParams class gains a new exists() member function

Changes in Rcpp version 0.6.5 (2009-04-01)

• Small OS X build correction using R_ARCH variable

• Include LGPL license as file COPYING

Changes in Rcpp version 0.6.4 (2009-03-01)

• 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)

Changes in Rcpp version 0.6.3 (2009-01-09)

• 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

Changes in Rcpp version 0.6.2 (2008-12-02)

• Small but important fix for Linux builds in Rcpp:::RcppLdFlags()

Changes in Rcpp version 0.6.1 (2008-11-30)

• 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

Changes in Rcpp version 0.6.0 (2008-11-05)

• 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