使用Rcpp連接StringVector

Question

我無法弄清楚如何連接2個字符串與Rcpp;並且文件沒有幫助我，但我懷疑有一個明顯的答案。

http://gallery.rcpp.org/articles/working-with-Rcpp-StringVector/

http://gallery.rcpp.org/articles/strings_with_rcpp/

StringVector concatenate(StringVector a, StringVector b) 
{ 
StringVector c; 
c= ??; 
return c; 
} 

我希望這樣的輸出：

a=c("a","b"); b=c("c","d"); 
concatenate(a,b) 
[1] "ac" "bd" 

Answer 1

可能有幾種不同的方式來處理這一點，但這裏有std::transform一個選項：

#include <Rcpp.h> 
using namespace Rcpp; 

struct Functor { 
    std::string 
    operator()(const std::string& lhs, const internal::string_proxy<STRSXP>& rhs) const 
    { 
     return lhs + rhs; 
    } 
}; 

// [[Rcpp::export]] 
CharacterVector paste2(CharacterVector lhs, CharacterVector rhs) 
{ 
    std::vector<std::string> res(lhs.begin(), lhs.end()); 
    std::transform(
     res.begin(), res.end(), 
     rhs.begin(), res.begin(), 
     Functor() 
    ); 
    return wrap(res); 
} 

/*** R 

lhs <- letters[1:2]; rhs <- letters[3:4] 

paste(lhs, rhs, sep = "") 
# [1] "ac" "bd" 

paste2(lhs, rhs) 
# [1] "ac" "bd" 

*/ 

---

其原因第一複印左手錶達成std::vector<std::string>在於internal::string_proxy<>類provides operator+與簽名

std::string operator+(const std::string& x, const internal::string_proxy<STRSXP>& y) 

而不是，例如

operator+(const internal::string_proxy<STRSXP>& x, const internal::string_proxy<STRSXP>& y) 

---

如果你的編譯器支持C++ 11，這是可以做到稍微乾淨：

// [[Rcpp::plugins(cpp11)]] 
#include <Rcpp.h> 
using namespace Rcpp; 

// [[Rcpp::export]] 
CharacterVector paste3(CharacterVector lhs, CharacterVector rhs) 
{ 
    using proxy_t = internal::string_proxy<STRSXP>; 

    std::vector<std::string> res(lhs.begin(), lhs.end()); 
    std::transform(res.begin(), res.end(), rhs.begin(), res.begin(), 
     [&](const std::string& x, const proxy_t& y) { 
      return x + y; 
     } 
    ); 

    return wrap(res); 
} 

/*** R 

lhs <- letters[1:2]; rhs <- letters[3:4] 

paste(lhs, rhs, sep = "") 
# [1] "ac" "bd" 

paste3(lhs, rhs) 
# [1] "ac" "bd" 

*/ 

Answer 2

我要離開這個答案了，但要注意關於由@nrussell提供的警告使用push_back()！

---

我仍然得到認真處理Rcpp自己，所以我在一個循環

library(Rcpp) 

cppFunction('StringVector concatenate(StringVector a, StringVector b) 
{ 
    StringVector c; 
    std::ostringstream x; 
    std::ostringstream y; 

// concatenate inputs 
    for (int i = 0; i < a.size(); i++) 
    x << a[i]; 

    for (int i = 0; i < b.size(); i++) 
    y << b[i]; 

    c.push_back(x.str()); 
    c.push_back(y.str()); 

    return c; 

}') 

a=c("a","b"); b=c("c","d"); 
concatenate(a,b) 
# [1] "ab" "cd" 

---

（I）的重複調用的性能比較走了一個字符串生成器針對（ii）預分配和填充策略，我們可以看到後者是優選的：

#include <Rcpp.h> 
using namespace Rcpp; 

// [[Rcpp::export]] 
CharacterVector pbpaste(CharacterVector lhs, CharacterVector rhs) 
{ 
    R_xlen_t i = 0, sz = lhs.size(); 
    CharacterVector res; 

    for (std::ostringstream oss; i < sz; i++, oss.str("")) { 
     oss << lhs[i] << rhs[i]; 
     res.push_back(oss.str()); 
    } 

    return res; 
} 

// [[Rcpp::export]] 
CharacterVector sspaste(CharacterVector lhs, CharacterVector rhs) 
{ 
    R_xlen_t i = 0, sz = lhs.size(); 
    CharacterVector res(sz); 

    for (std::ostringstream oss; i < sz; i++, oss.str("")) { 
     oss << lhs[i] << rhs[i]; 
     res[i] = oss.str(); 
    } 

    return res; 
} 

/*** R 

lhs <- as.character(1:5000); rhs <- as.character(5001:10000) 

all.equal(pbpaste(lhs, rhs), sspaste(lhs, rhs)) 
# [1] TRUE 

microbenchmark::microbenchmark(
    "push_back" = pbpaste(lhs, rhs), 
    "preallocate" = sspaste(lhs, rhs), 
    times = 200L 
) 
# Unit: milliseconds 
#   expr  min   lq  mean  median   uq  max neval cld 
# push_back 101.521579 105.334649 115.156544 107.275678 110.957420 256.722239 200 b 
# preallocate 1.364213 1.585818 1.789564 1.778153 1.934758 2.955352 200 a 

*/ 

Answer 3

一個工作解決方案是使用：

#include <Rcpp.h> 
using namespace Rcpp; 

// [[Rcpp::export]] 
CharacterVector concatenate(std::string x, std::string y) 
{ 
       return wrap(x + y); 
} 

然後：

Vconcatenate=Vectorize(concatenate) 
Vconcatenate(letters[1:2],letters[3:4]) 

或者：

// [[Rcpp::export]] 
CharacterVector concatenate(std::vector<std::string> x,std::vector<std::string> y) 
{ 
    std::vector<std::string> res(x.size()); 
    for (int i=0; i < x.size(); i++) 
    { 
    res[i]=x[i]+y[i]; 
    } 
    return wrap(res); 
}