- 전체
- Sample DB
- database modeling
- [표준 SQL] Standard SQL
- G-SQL
- 10-Min
- ORACLE
- MS SQLserver
- MySQL
- SQLite
- postgreSQL
- 데이터아키텍처전문가 - 국가공인자격
- 데이터 분석 전문가 [ADP]
- [국가공인] SQL 개발자/전문가
- NoSQL
- hadoop
- hadoop eco system
- big data (빅데이터)
- stat(통계) R 언어
- XML DB & XQuery
- spark
- DataBase Tool
- 데이터분석 & 데이터사이언스
- Engineer Quality Management
- [기계학습] machine learning
- 데이터 수집 및 전처리
- 국가기술자격 빅데이터분석기사
- 암호화폐 (비트코인, cryptocurrency, bitcoin)
stat(통계) R 언어 [R 데이터 분석] Using C/C++ in R , R언어에서 C/C++ 사용하기
2021.11.21 23:45
[R 데이터 분석] Using C/C++ in R , R언어에서 C/C++ 사용하기
Using C/C++ in R
Statistics 506, Fall 2017
Resources
- R’s C interface
- Chapter 15 of The Art of R Programming
- Chapter 20 of Advanced R
- “System and foreign language interfaces”, Section 5 of Writing R Extensions
- Learning C
- Rcpp
- rcpp.org
- Gallery
- Chapter 19 of Advanced R
- Rcpp Quick Reference
- Learning C++
C and C++ Basics
These are compiled languages and hence a compiler is needed to transform a human interpret able program into a machine executable one. The most commonly use compiler is gcc. This is already installed on most Linux distributions, including all the servers we have commonly used in this course. If you wish to compile C/C++ programs on your personal computer, you will need to install a compiler.
Mac users should download Xcode from Apple’s app store. Windows users should investigate Rtools or Cygwin.
There are three important differences from R
- Variables and functions need to be declared before use.
- Arrays are indexed from zero.
- Arrays are stored in row-major order.
- Statements are delimited using semicolons “;”.
- Loops have minimal overhead and hence generally do not need to be avoided.
C Basics
We will review the following topics from C Tutorial:
- Program Structure
- Basic Syntax
- Data types (Integer and Floating Point Types)
- Variables
- Operators (Arithmetic, Relational, Logical and Assignment)
- Loops
- Arrays
- Pointers
- Type Casting
We will not review these as they work very much like in R:
- Decision Making
The remaining sections are mostly beyond the scope of what we will discuss here.
Calling C functions from R
We can call a function written in C from R using .C()
or .call()
. We begin with .C
as it is simpler.
Using .C()
The basic recipe for using .C
is as follows:
-
Write a function in
.C
that returnsvoid
and stores the desired result in one or more arguments expressly created for this purpose. Your function should have aC_
prefix. -
Compile your function into a shared library accessible to R using this command:
R CMD SHLIB my_func.c
withmy_func.c
replaced by your c program. -
Within an active R session, link to the shared library using
dyn.load("my_func.so")
. -
Write an R wrapper to call your C function using
.C
with the following syntax:.C("C_my_func", arg1, arg2)
. The reason to use an R wrapper is to ensure that the arguments passed are of the correct size and type in order to avoid potentially fatal errors.
The middle two steps can be avoided by including these functions into an R package. We will discuss this briefly when turning to C++ and Rcpp.
A conceptual key to understanding how .C
works is realizing that function arguments are passed as pointers to objects in memory rather than by value.
We will look at some examples of C coding available here.
Using .Call()
We can use .Call()
to create and modify R level objects directly using functions in C. R level objects are of type SEXP
for “S-expression”. These types are defined in the header file Rinternals.h
which should be included in all C functions to be called with .Call()
.
When we create R level objects, we must protect them from garbage collection using PROTECT
or a similar function. We later UNPROTECT
them to allow the memory to be reallocated.
Recall that scalars in R are length one vectors. Consequently, the must be coerced to C type scalars to be uses as such. This can be done using the C functions as*
: asLogical
, asInteger
, asReal
, CHAR(asChar())
.
Here is a simple example using the inline::cfunction
.
library(inline)
##
## Attaching package: 'inline'
## The following object is masked from 'package:Rcpp':
##
## registerPlugin
seqn = cfunction(signature(n_="integer", start_="integer"),
body="
int i, n = asInteger(n_), start=asInteger(start_);
SEXP out = PROTECT(allocVector(INTSXP, n));
for(i=0; i<n; ++i){
INTEGER(out)[i]=i+start;
}
UNPROTECT(1);
return out;
")
seqn(8, 3)
## [1] 3 4 5 6 7 8 9 10
fib = cfunction(c(n_="integer"), body=
"
/* Declaratations */
int n = asInteger(n_);
SEXP out = PROTECT(allocVector(INTSXP, n));
/* Function Body */
INTEGER(out)[0] = 1;
if(n > 1) INTEGER(out)[1]=1;
if(n > 2)
{
for(int i=2; i<n; i++)
{
INTEGER(out)[i] = INTEGER(out)[i-2] + INTEGER(out)[i-1];
}
}
/* Clean up and return */
UNPROTECT(1);
return out;
")
fib(10)
## [1] 1 1 2 3 5 8 13 21 34 55
Modifying inputs
Be careful about modifying input arguments without duplicating first as other R objects may point to the same location in memory owing to “copy-on-modify” semantics.
Here is a quick example from p. 441 of Advanced R using the “inline” package.
add_three = cfunction(c(x="numeric"),
"
REAL(x)[0] = REAL(x)[0] + 3;
return x;
")
y <- x <- 1
add_three(x)
## [1] 4
x
## [1] 4
y
## [1] 4
Here is a corrected version in which the argument is duplicated rather than modified in place.
add_3 = cfunction(c(x_="numeric"),
"
SEXP x = PROTECT(duplicate(x_));
REAL(x)[0] = REAL(x)[0] + 3;
UNPROTECT(1);
return x;
")
y <- x <- 1
add_3(x)
## [1] 4
x
## [1] 1
y
## [1] 1
Interfacing with C++ via Rcpp
The Rcpp package greatly simplifies the process of exposing functions written in C++ to R.
Using sourceCpp
We can use the function sourceCpp
to read a function written in C++ into R interactively. The function takes care of the compilation using R CMD SHLIB
and automatically generates an R wrapper for the underlying function. The shared library and other files will be written to the directory specified by cacheDir
which defaults to a temporary directory for automated clean up.
To use a C++ function via sourceCpp:
- Write a your C++ function in a file with extension
.cpp
. - In the source file, be sure to
#include <Rcpp.h>
. - Designate functions exposed to R using the tag
// [[Rcpp::export]]
. - Compile and source your function using
sourceCpp()
and a link to the file.
Here are some minimal examples based on generating Fibonacci numbers. You can download the source code here.
The final Fibonacci example here makes two changes from the previous example:
-
We add the line
using namespace rcpp;
to avoid having to type the prefixRcpp::
when referring to the Rcpp namespace. This is much like usinglibrary()
within R to add a package to the search path. -
We show how to print to the R console from within the C++ function using
Rcout
. This can be useful for manual debugging.
#include <Rcpp.h>
using namespace Rcpp;
// [[Rcpp::export]]
IntegerVector FibCpp2(int n)
{
// Error checking
if(n <= 0)
{
throw std::range_error("n must be a positive integer");
}
// Allocate memory
IntegerVector out(n);
out[0]=1;
Rcout << "Starting computations ... ";
// Compute additional terms
if(n > 0)
{
out[1]=1;
int i;
for(i=2; i<n; i++)
{
out[i] = out[i-1] + out[i-2];
}
}
Rcout << "done." << std::endl;
return out;
}
sourceCpp('~/Stats506/FibCPP2.cpp')
FibCpp2(10)
## Starting computations ... done.
## [1] 1 1 2 3 5 8 13 21 34 55
Example
Here is another simple example.
Building a package with Rcpp
The sourceCpp
function is convenient for interactive use and initial development. However, for larger projects with multiple functions it is better to maintain the code base using an R package. Rcpp automates much of the work involved in doing this via the compileAttributes
function.
This function creates a C++ wrapper to any C++ functions tagged with the // [[Rcpp::export]]
attribute that handles type conversion and an R wrapper that calls this function in turn. This makes for a relatively seamless process in which you only occasionally need to look into the translation details.
In the download above is avery simple R package Pkg
with the getRegion
function from the previous example.
[출처] https://jbhender.github.io/Stats506/F17/Using_C_Cpp.html
광고 클릭에서 발생하는 수익금은 모두 웹사이트 서버의 유지 및 관리, 그리고 기술 콘텐츠 향상을 위해 쓰여집니다.
댓글 0
번호 | 제목 | 글쓴이 | 날짜 | 조회 수 |
---|---|---|---|---|
공지 | 오라클 기본 샘플 데이터베이스 | 졸리운_곰 | 2014.01.02 | 25085 |
공지 | [SQL컨셉] 서적 "SQL컨셉"의 샘플 데이타 베이스 SAMPLE DATABASE of ORACLE | 가을의 곰을... | 2013.02.10 | 24564 |
공지 | [G_SQL] Sample Database | 가을의 곰을... | 2012.05.20 | 25943 |
1 | [hadoop] Python으로 Hive 연결하기 | 졸리운_곰 | 2021.03.04 | 263 |