Module

Name of the module, as declared in the <code>RCPP_MODULE</code> macro internally

module

Passed to <code><a href="/link/getNativeSymbolInfo?package=Rcpp&version=0.8.2" rd-options="" data-mini-rdoc="Rcpp::getNativeSymbolInfo">getNativeSymbolInfo</a></code>

PACKAGE

When the module is loaded, S4 classes are defined based on the 
	internal classes. This argument is passed to <code><a href="/link/setClass?package=Rcpp&version=0.8.2" rd-options="" data-mini-rdoc="Rcpp::setClass">setClass</a></code>

where

Retrieves an Rcpp module from a dynamic library, usually associated with a 
package.

programming

Seamless R and C++ integration The Rcpp package contains a
        C++ library that facilitates the integration of R and C++ in
        various ways.

 R data types (SEXP) are matched to C++ objects in a class hierarchy.
        All R types are supported (vectors, functions, environment, etc
        ...)  and each type is mapped to a dedicated class. For
        example, numeric vectors are represented as instances of the
        Rcpp::NumericVector class, environments are represented as
        instances of Rcpp::Environment, functions are represented as
        Rcpp::Function, etc ...

 The underlying C++ library also offers the Rcpp::wrap function which is
        a templated function that transforms an arbitrary object into a
        SEXP.  This makes it straightforward to implement C++ logic in
        terms of standard C++ types such as STL containers and then
        wrap them when they need to be returned to R. Internally, wrap
        uses advanced template meta programming techniques and
        currently supports : primitive types (bool, int, double,
        size_t, Rbyte, Rcomplex, std::string), STL containers (e.g
        std::vector<T>) where T is wrappable, STL maps (e.g
        std::map<std::string,T>) where T is wrappable, and arbitrary
        types that support implicit conversion to SEXP.

 The reverse conversion (from R to C++) is performed by the Rcpp::as
        function template offering a similar degree of flexibility.

 The package also contains a set of classes---which we call the `classic
        Rcpp API'---that were provided in an earlier API for R and C++
        integration. Due to its continued use, the classic API is
        retained and will be supported for the foreseable future. The
        classic API includes support for R types real, integer,
        character, vector, matrix, Date, datetime (i.e.  POSIXct) at
        microsecond resolution, data frame, and function. Transfer to
        and from simple or complex SEXP objects is made easy thanks to
        automatic conversion made possible by C++ template conversion.
        Calling R functions from C++ is also supported.

 C++ code can be 'inlined' by using the 'inline' package which will
        create a C++ function and compile, link and load it given the
        'inlined' character argument which makes C++ integration very
        easy.

 Several examples are included, and over 550 unit tests in over 250 unit
        test functions provide addtional usage examples.

Module: Retrieves an Rcpp module

Description

Usage

Arguments

Value