[Rcpp-commits] r1287 - pkg/Rcpp
noreply at r-forge.r-project.org
noreply at r-forge.r-project.org
Thu May 20 09:36:54 CEST 2010
Author: edd
Date: 2010-05-20 09:36:53 +0200 (Thu, 20 May 2010)
New Revision: 1287
Modified:
pkg/Rcpp/NEWS
Log:
ok -- I think I may have inconsisten tab settings across machines so now I just
ran M-x untabify which should finally freeze this in a nicely formatted way
Modified: pkg/Rcpp/NEWS
===================================================================
--- pkg/Rcpp/NEWS 2010-05-20 07:15:37 UTC (rev 1286)
+++ pkg/Rcpp/NEWS 2010-05-20 07:36:53 UTC (rev 1287)
@@ -1,253 +1,253 @@
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:
-
- 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
-
+ 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
+
o 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 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 )
-
- o Rcpp now depends on inline (>= 0.3.4)
-
+ 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 )
+
+ 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::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.
-
- o Revert to not double-quote protecting the path on Windows as this
- breaks backticks expansion used n Makevars.win etc
+ 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
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
o Undo shQuote() to protect Windows path names (which may contain
spaces) as backticks use is still broken; use of $(shell ...) works
-0.7.11 2010-03-26
+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.
+ o 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.
- o Matrix now has a diag() method to create diagonal matrices, and
- a new constructor using a single int to create square matrices
+ o Matrix now has a diag() method to create diagonal matrices, and
+ 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 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)
-
- o Applied patch by Alistair Gee to make ColDatum more robust
+ Named(.,.) and Named(.)=. are preserved, and extended to work also on
+ simple vectors (through Vector<>::create)
- o Fixed a bug in Vector that caused random behavior due to the lack of
+ o Applied patch by Alistair Gee to make ColDatum more robust
+
+ o Fixed a bug in Vector that caused random behavior due to the lack of
copy constructor in the Vector template
0.7.10 2010-03-15
o new class Rcpp::S4 whose constructor checks if the object is an S4
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)
0.7.9 2010-03-12
- o Another small improvement to Windows build flags
+ 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
+ o bugfix on 64 bit platforms. The traits classes (wrap_type_traits, etc)
+ 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
- o 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
-
- o 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...
-
- o 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
-
- o 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
+ o 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
+
+ o 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...
+
+ o 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
+
+ o 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
- o 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
+ o 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
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;
+ o RcppExample et al have been moved to a new package RcppExamples;
src/Makevars and src/Makevars.win simplified accordingly
- o 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.
+ o 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.
- o Improved src/Makevars.win thanks to Brian Ripley
+ o Improved src/Makevars.win thanks to Brian Ripley
- o New examples for 'fast lm' using compiled code:
+ o 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
- o A new package RcppArmadillo (to be released shortly) now serves
+ 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
+ o Added a new vignette 'Rcpp-introduction' based on a just-submitted
overview article on Rcpp
-0.7.7 2010-02-14
+0.7.7 2010-02-14
- o new template classes Rcpp::unary_call and Rcpp::binary_call
- that facilitates using R language calls together
- with STL algorithms.
-
- o fixed a bug in Language constructors taking a string as their
- first argument. The created call was wrong.
+ o new template classes Rcpp::unary_call and Rcpp::binary_call
+ that facilitates using R language calls together
+ with STL algorithms.
+
+ o fixed a bug in Language constructors taking a string as their
+ first argument. The created call was wrong.
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
@@ -259,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;
@@ -267,393 +267,393 @@
o RObject::asFoo deprecated in favour of Rcpp::as<Foo>
-0.7.5 2010-02-08
+0.7.5 2010-02-08
- o 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)
-
- o 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
+ o 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)
+
+ o 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
- o a new namespace Rcpp::traits has been added to host the various
- type traits used by wrap
+ o a new namespace Rcpp::traits has been added to host the various
+ type traits used by wrap
- o The doxygen documentation now shows the examples
+ o The doxygen documentation now shows the examples
- o A new file inst/THANKS acknowledges the kind help we got from others
+ o A new file inst/THANKS acknowledges the kind help we got from others
- o The RcppSexp has been removed from the library.
+ o The RcppSexp has been removed from the library.
- o The methods RObject::asFoo are deprecated and will be removed
- in the next version. The alternative is to use as<Foo>.
+ o The methods RObject::asFoo are deprecated and will be removed
+ in the next version. The alternative is to use as<Foo>.
- o The method RObject::slot can now be used to get or set the
- associated slot. This is one more example of the proxy pattern
-
- o Rcpp::VectorBase gains a names() method that allows getting/setting
- the names of a vector. This is yet another example of the
- proxy pattern.
-
- o Rcpp::DottedPair gains templated operator<< and operator>> that
- allow wrap and push_back or wrap and push_front of an object
-
- o 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.
-
- o 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)
-
- o added support for 64-bit Windows (thanks to Brian Ripley and Uwe Ligges)
-
-0.7.4 2010-01-30
+ o The method RObject::slot can now be used to get or set the
+ associated slot. This is one more example of the proxy pattern
+
+ o Rcpp::VectorBase gains a names() method that allows getting/setting
+ the names of a vector. This is yet another example of the
+ proxy pattern.
+
+ o Rcpp::DottedPair gains templated operator<< and operator>> that
+ allow wrap and push_back or wrap and push_front of an object
+
+ o 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.
+
+ o 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)
+
+ o added support for 64-bit Windows (thanks to Brian Ripley and Uwe Ligges)
+
+0.7.4 2010-01-30
- o matrix-like indexing using operator() for all vector
- types : IntegerVector, NumericVector, RawVector, CharacterVector
- LogicalVector, GenericVector and ExpressionVector.
+ o matrix-like indexing using operator() for all vector
+ types : IntegerVector, NumericVector, RawVector, CharacterVector
+ LogicalVector, GenericVector and ExpressionVector.
- o new class Rcpp::Dimension to support creation of vectors with
- dimensions. All vector classes gain a constructor taking a
- Dimension reference.
+ o new class Rcpp::Dimension to support creation of vectors with
+ dimensions. All vector classes gain a constructor taking a
+ Dimension reference.
- o an intermediate template class "SimpleVector" has been added. All
- simple vector classes are now generated from the SimpleVector
- template : IntegerVector, NumericVector, RawVector, CharacterVector
- LogicalVector.
+ o an intermediate template class "SimpleVector" has been added. All
+ simple vector classes are now generated from the SimpleVector
+ template : IntegerVector, NumericVector, RawVector, CharacterVector
+ LogicalVector.
- o an intermediate template class "SEXP_Vector" has been added to
- generate GenericVector and ExpressionVector.
+ o an intermediate template class "SEXP_Vector" has been added to
+ generate GenericVector and ExpressionVector.
- o the clone template function was introduced to explicitely
- clone an RObject by duplicating the SEXP it encapsulates.
+ o the clone template function was introduced to explicitely
+ clone an RObject by duplicating the SEXP it encapsulates.
- o even smarter wrap programming using traits and template
+ o even smarter wrap programming using traits and template
meta-programming using a private header to be include only
RcppCommon.h
- o 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.
+ o 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.
- o 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.
+ o 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.
- o all specializations of wrap : wrap<double>, wrap< vector<double> >
- use coercion to deal with missing values (NA) appropriately.
+ o all specializations of wrap : wrap<double>, wrap< vector<double> >
+ use coercion to deal with missing values (NA) appropriately.
- o configure has been withdrawn. C++0x features can now be activated
- by setting the RCPP_CXX0X environment variable to "yes".
+ o configure has been withdrawn. C++0x features can now be activated
+ by setting the RCPP_CXX0X environment variable to "yes".
- o 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
+ o 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
- o 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 */
+ o 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 */
- o Environment::assign becomes a template and also uses wrap to
- create a suitable SEXP
+ o Environment::assign becomes a template and also uses wrap to
+ create a suitable SEXP
- o Many more unit tests for the new features; also added unit tests
+ o Many more unit tests for the new features; also added unit tests
for older API
-0.7.3 2010-01-21
+0.7.3 2010-01-21
- o New R function Rcpp.package.skeleton, modelled after
- utils::package.skeleton to help creating a package with support
- for Rcpp use.
+ o New R function Rcpp.package.skeleton, modelled after
+ utils::package.skeleton to help creating a package with support
+ for Rcpp use.
- o indexing is now faster for simple vectors due to inlining of
- the operator[] and caching the array pointer
+ o indexing is now faster for simple vectors due to inlining of
+ the operator[] and caching the array pointer
- o 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 ...
+ o 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 ...
- o 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.
+ o 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.
- o Improved detection of C++0x capabilities
+ o Improved detection of C++0x capabilities
- o Rcpp::Pairlist gains a default constructor
+ o Rcpp::Pairlist gains a default constructor
- o Rcpp::Environment gains a new_child method to create a new
- environment whose parent is this
+ o Rcpp::Environment gains a new_child method to create a new
+ environment whose parent is this
- o Rcpp::Environment::Binding gains a templated implicit
- conversion operator
-
- o Rcpp::ExpressionVector gains an eval method to evaluate itself
+ o Rcpp::Environment::Binding gains a templated implicit
+ conversion operator
+
+ o Rcpp::ExpressionVector gains an eval method to evaluate itself
- o Rcpp::ExpressionVector gains a constructor taking a std::string
- representing some R code to parse.
+ o Rcpp::ExpressionVector gains a constructor taking a std::string
+ representing some R code to parse.
- o Rcpp::GenericVector::Proxy gains an assignment operator to deal
- with Environment::Proxy objects
+ o Rcpp::GenericVector::Proxy gains an assignment operator to deal
+ with Environment::Proxy objects
- o Rcpp::LdFlags() now defaults to static linking OS X, as it already
+ o Rcpp::LdFlags() now defaults to static linking OS X, as it already
did on Windows; this default can be overridden.
-0.7.2 2010-01-12
+0.7.2 2010-01-12
- o a new benchmark was added to the examples directory
- around the classic convolution example from
- Writing R extensions to compare C and C++ implementations
+ o a new benchmark was added to the examples directory
+ around the classic convolution example from
+ Writing R extensions to compare C and C++ implementations
[TRUNCATED]
To get the complete diff run:
svnlook diff /svnroot/rcpp -r 1287
More information about the Rcpp-commits
mailing list