Recupera i parametri dalla lista usando RCPP

Question

Nuovo a RCPP PROVA TROVARE Come recuperare e utilizzare un elenco annidato da R con una struttura nota senza copiare nuovamente parti dell'elenco.Il piccolo esempio di codice (con codice R Embedded) sembra funzionare (Cout è usato per il debug).

L'elenco RL recuperato da R potrebbe essere molto grande, quindi non voglio riallocare la memoria (copia parti di RL).Effettuare il codice corrente Copia parti di RL?

Best lars

#include <Rcpp.h>
#include <iostream>
using namespace Rcpp;
using namespace std;

// [[Rcpp::export]]
SEXP testing(const List rL) {
   List L(rL);
   SEXP sL2(L["L2"]);
   List L2(sL2);

   SEXP sStateGrpL2(L2["stateGroups"]);
   List stateGrpL2(sStateGrpL2);
   SEXP sStateAllocL2(L2["stateAlloc"]);   
   CharacterVector stateAllocL2(sStateAllocL2);

   SEXP sActionGrpL2(L2["actionGroups"]);
   List actionGrpL2(sActionGrpL2);
   SEXP sActionAllocL2(L2["actionAlloc"]);
   List actionAllocL2(sActionAllocL2);

   vector<string> stateLabels; 
   vector<string> actionLabels;
   CharacterVector actionNames;

   for(int n2 = 0; n2< as<int>(L2["stages"]); n2++) {
      stateLabels = as< vector<string> >(stateGrpL2[as<string>(stateAllocL2[n2])]);
      int s2Size = stateLabels.size(); 
      SEXP sAllocA(actionAllocL2[n2]);
      List allocA(sAllocA);
      actionNames = as<CharacterVector>(allocA[0]);
      cout << "stage:" << n2 << " sN:" << as<string>(stateAllocL2[n2]) << "\n";
      for (int s2=0; s2<s2Size; ++s2) { 
        cout << " s:" << stateLabels[s2] << " aN:" << actionNames[s2] << "\n";
        actionLabels = as< vector<string> >(actionGrpL2[ as<string>(actionNames[s2]) ]);
        int a2Size = actionLabels.size();
        for (int a2=0; a2<a2Size; ++a2) {
           cout << "    a:" << actionLabels[a2] << "\n";
        }
      }
   }

   return wrap(0);
}


/*** R 
L <- list( L2=list(stages=2, 
                   stateGroups=list(s1Grp=c("a","b","c"),s2Grp=c("d","e")), 
                   stateAlloc = c(rep("s1Grp",1),rep("s2Grp",1)), 
                   actionGroups = list(a1Grp=c("terminate","keep"), a2Grp=c("finish")),
                   actionAlloc = list(list( rep("a1Grp",3) ),
                                       list( c("a1Grp","a2Grp") )
                                       )
                   )
     )
testing(L)
*/

.

Answer 1

Scrivi:

.

L'elenco RL potrebbe essere molto grande, quindi non voglio usare la nuova memoria (copia parti di rl).È così il modo di farlo?

Abbastanza (per quanto posso dire da un'occhiata al tuo codice).

Tutto lo scambio con R utilizza i tipi di generazione di SEXP in cui il P supporta il puntatore - questi sono oggetti per proxy poco profondi che non saranno copiati .Utilizza / riutilizza la memoria dell'oggetto R.

Quindi se sei profilo / Memory-Profilo Questo dovrebbe comportarsi in modo simile per n= 10 e n= 1E5.Ma la prova è nel budino ...

Answer 2

Alcune cose:

.

• The Loop Test n2< as<int>(L2["stages"]) è sia difficile da leggere e inefficiente in quanto è calcolato ad ogni iterazione.Dovresti Sicuramente farlo solo una volta.

• Tutto il tuo as< vector<string> > crea copie profonde e no Approfitta della cache della stringa di R.Non puoi usare a CharacterVector invece?