[Rcpp-commits] r1286 - pkg/Rcpp
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Thu May 20 09:15:37 CEST 2010
Author: edd
Date: 2010-05-20 09:15:37 +0200 (Thu, 20 May 2010)
New Revision: 1286
Modified:
pkg/Rcpp/NEWS
Log:
reindented a number of paragraphs, no content changes
Modified: pkg/Rcpp/NEWS
===================================================================
--- pkg/Rcpp/NEWS 2010-05-20 07:14:53 UTC (rev 1285)
+++ pkg/Rcpp/NEWS 2010-05-20 07:15:37 UTC (rev 1286)
@@ -1,133 +1,132 @@
0.8.0 2010-05-17
o 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.
+ allowing use of 'LinkingTo: Rcpp'. But the Makevars and Makevars.win
+ are still needed to link against the user library.
o 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:
+ 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___ ) ;
- }
+ 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.
+ 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
+ BEGIN_RCPP
+ // user code
+ END_RCPP
o new __experimental__ macros
- The macros RCPP_FUNCTION_0, ..., RCPP_FUNCTION_65 to help creating C++
- functions hiding some code repetition:
+ 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 ;
- }
+ 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
+ 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.
+ 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
- }
-
+ 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:
+ 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 ;
- }
+ class Foo{
+ public:
+ int bar ;
+ }
- RCPP_XP_FIELD_GET( Foo_bar_get, Foo, 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.
+ 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:
+ 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 ) ;
+ 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
+ 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
+ The macro RCPP_XP_FIELD generates both getter and setter. For example
- RCPP_XP_FIELD( Foo_bar, Foo, bar )
+ 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
+ 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:
+ 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 )
+ 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.
+ 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
+ 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 )
+ 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.
+ 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 )
+ 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 :
+ Assuming xp is an external pointer to a std::vector<int>, this could
+ be called like this :
- .Call( "foobar", xp, 2L )
+ .Call( "foobar", xp, 2L )
o Rcpp now depends on inline (>= 0.3.4)
o 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
+ 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
o new class Rcpp::Formula to help building formulae in C++
o new class Rcpp::DataFrame to help building data frames in C++
o 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
+ used with an empty list, so that only the skeleton is generated. It
+ has also been reworked to show how to use LinkingTo: Rcpp
o 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.
+ unsigned long, short and unsigned short which are silently converted
+ to the most acceptable R type.
o Revert to not double-quote protecting the path on Windows as this
- breaks backticks expansion used n Makevars.win etc
+ breaks backticks expansion used n Makevars.win etc
o Exceptions classes have been moved out of Rcpp classes,
- e.g. Rcpp::RObject::not_a_matrix is now Rcpp::not_a_matrix
+ e.g. Rcpp::RObject::not_a_matrix is now Rcpp::not_a_matrix
0.7.12 2010-04-16
@@ -137,17 +136,17 @@
0.7.11 2010-03-26
o Vector<> gains a set of templated factory methods "create" which
- takes up to 20 arguments and can create named or unnamed vectors.
+ takes up to 20 arguments and can create named or unnamed vectors.
This greatly facilitates creating objects that are returned to R.
o Matrix now has a diag() method to create diagonal matrices, and
- a new constructor using a single int to create square matrices
+ a new constructor using a single int to create square matrices
o Vector now has a new fill() method to propagate a single value
o 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)
+ Named(.,.) and Named(.)=. are preserved, and extended to work also on
+ simple vectors (through Vector<>::create)
o Applied patch by Alistair Gee to make ColDatum more robust
@@ -160,9 +159,9 @@
object
o 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
+ 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
o use shQuote() to protect Windows path names (which may contain spaces)
@@ -171,12 +170,12 @@
o Another small improvement to Windows build flags
o bugfix on 64 bit platforms. The traits classes (wrap_type_traits, etc)
- used size_t when they needed to actually use unsigned int
+ used size_t when they needed to actually use unsigned int
o 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.
+ 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.
0.7.8 2010-03-09
@@ -211,7 +210,7 @@
types. The package RcppArmadillo has examples of this
o new template class Rcpp::fixed_call that can be used in STL algorithms
- such as std::generate.
+ such as std::generate.
o RcppExample et al have been moved to a new package RcppExamples;
src/Makevars and src/Makevars.win simplified accordingly
@@ -231,7 +230,7 @@
o 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
+ C++ library such as the heavily-templated Armadillo library
o Added a new vignette 'Rcpp-introduction' based on a just-submitted
overview article on Rcpp
@@ -248,7 +247,7 @@
0.7.6 2010-02-12
o SEXP_Vector (and ExpressionVector and GenericVector, a.k.a List) now
- have methods push_front, push_back and insert that are templated
+ have methods push_front, push_back and insert that are templated
o SEXP_Vector now has int- and range-valued erase() members
@@ -260,7 +259,7 @@
so that STL algorithms can be applied to Rcpp objects
o CharacterVector gains a random access iterator, begin() and end() to
- support STL algorithms; iterator dereferences to a StringProxy
+ support STL algorithms; iterator dereferences to a StringProxy
o Restore Windows build; successfully tested on 32 and 64 bit;
@@ -371,9 +370,9 @@
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 */
+ Foo foo = env["x"] ; /* as<Foo> is used */
+ Bar bar ;
+ env["y"] = bar ; /* wrap<Bar> is used */
o Environment::assign becomes a template and also uses wrap to
create a suitable SEXP
@@ -486,7 +485,7 @@
C++ builtin and stl types. Factored out of RObject
o new class Rcpp::Named to deal with named with named objects
- in a pairlist, or a call
+ in a pairlist, or a call
o new class Rcpp::Symbol to manage symbols (SYMSXP)
More information about the Rcpp-commits
mailing list