Rcpp & main/optim.c - How to translate `void *ex` after passing the variable through `nmmin()`?

Main question: How to format a complex struct in Rcpp that will be accepted by optim.c? and how will this struct be modified when returned to the defined optimfn function?

Background: I'm writing an EM algorithm in Rcpp that will be used in a beta mixture model. I am trying to use a simple nelder mead numerical optimization approach through the R API (nmmin), however I am having a hard time passing the variable list through. I'm very very new to C++/Rcpp.

Information:

eout countains:

• zprobs: a matrix (double[45203x5]). (the number of col and rows will vary).
• parmlist: a list which contains lists avec, mvec, and svec (each list of 5 doubles). (the length will vary).
• xi: a list of doubles of length 45203. (the length will vary).
• denom: a list of doubles of length 45203. (the length will vary).

To pass my variables through to nmmin, I've tried to convert it to a struct format by first converting the NumericMatrix and NumericVector into double *var, (but I then learned these are not real (edit: that these do not hold vectors)), followed by creating an object with my defined struct with these items. The current method is able to compile, but I am not sure what *ex looks like when it enters the enlikeB function. I also tried to convert the Rcpp::List items to std::vectors, in case these were possible to pass through.

Where I am currently:

#include <RcppCommon.h>

typedef struct{
  double *xi;
  int xil;
  int zrows;
  int zcols;
  double *zdata;
  double *denom;
  int denoml;
}Ething;

#include <Rcpp.h>

//HELPER FUNCTIONS HERE:
//


// Defining the optimfn function:
typedef double optimfn(int n, double *par, void *ex);

double elnlikeB(int n, double *par, void *ex) {
 
   Rcpp::Rcout << "entering elnlikeB\n";
   Rcpp::Rcout << "The value of ex: " << ex << "\n";

   Ething *et = (Ething *) ex;
   Rcpp::Rcout << "The value of et : " << et << "\n";

   Rcpp::Rcout << "making z\n";
   int zrows = et ->zrows;
   int zcols = et ->zcols;
   double *z = et ->zdata;
   Rcpp::NumericMatrix Zprobsmat;
   int count = 0;
   for(int x = 0; x < zcols; x++) {
     for(int y = 0; y < zrows; y++) {
       Zprobsmat(y, x) = z[count]; //row, column
       count = count +1;
     }
   }
   Rcpp::Rcout << "The value of zprob : " << Zprobsmat << "\n";
   
   Rcpp::Rcout << "making xi\n";
   int xil = et -> xil;
   double *xid = et -> xi;
   Rcpp::NumericVector xi;
   for(int nn = 0; nn < xil; nn++){
     xi[nn] = xid[nn];
   } 
   Rcpp::Rcout << "The value of xi : " << xi << "\n";
   
   Rcpp::Rcout << "making denom\n";
   int denoml = et ->denoml;
   double *denomd =  et -> denom; 
   Rcpp::NumericVector denom;
   for(int nn = 0; nn < denoml; nn++){
     denom[nn] = denomd[nn];
   } 
   Rcpp::Rcout << "The value of denom: " << denom << "\n";
   
   Rcpp::Rcout << "making myguess\n";
   Rcpp::NumericVector myguess;
   for(int nn = 0; nn < n; nn++){
    myguess[nn] = par[nn];
   } 
   Rcpp::Rcout << "The value of myguess: " << myguess << "\n";
   
   //This section works is the vectors and matrix are correct//
   Rcpp::Rcout << "calculating\n";
   int nnew = xi.size();
   int nmixt = Zprobsmat.ncol();
   int gsize = myguess.size();
   
   Rcpp::NumericVector avec(nmixt);
   avec[Rcpp::Range(0, (nmixt - 2))] = invmlogitc(myguess[Rcpp::Range(0, (nmixt - 2))]);
   avec[(nmixt-1)] = (1 - rcpp_sum(avec));
   Rcpp::NumericVector mvec(nmixt);
   Rcpp::NumericVector svec(nmixt);
      
   mvec = mutransform(myguess[Rcpp::Range((nmixt-1), (((nmixt-1)*2)))]);
   svec = stransform(myguess[Rcpp::Range((((nmixt-1)*2)+1), (gsize-1))]);
   
   Rcpp::NumericMatrix loglikemat( nnew, nmixt );
   Rcpp::NumericMatrix lnfr( nnew, nmixt );
   double sum = 0;
   
   for(int i = 0; i < nmixt; i++){
     double a = log(avec[i]);
     double m = mvec[i];
     double s = svec[i];
     Rcpp::NumericVector ab = alphabetacalc(m, s);
     for( int z = 0;  z < nnew; z++){
         lnfr(z,i) = (R::dbeta( xi[z], ab[0], ab[1], true));
       
         double left = (Zprobsmat(z,i)/denom[z]);
         double right = (a + lnfr(z,i));
         loglikemat(z, i) = (left*right);
         sum += loglikemat(z, i);
     }
   }
   sum = (-sum);
   Rprintf("sum: %d \n", sum);
   return(sum);
 }

optimfn elnlikeB;
 
//More helpers
 extern "C" {
   void nmmin(int n, double *xin, double *x, double *Fmin, optimfn fn,
              int *fail, double abstol, double intol, void *ex,
              double alpha, double beta, double gamma, int trace,
              int *fncount, int maxit);
 }
 
// [[Rcpp::export]]
Rcpp::List optim_test(Rcpp::List eout){
   Rcpp::Rcout << "starting\n";
   Rcpp::Rcout << "making avec, mvec, svec\n"; 
   Rcpp::List parmlist = eout["parm.list"];
   Rcpp::NumericVector avec = parmlist["avec"];
   Rcpp::NumericVector mvec = parmlist["mvec"];
   Rcpp::NumericVector svec = parmlist["svec"];
   Rcpp::Rcout << "making zprob and xi \n"; 
   Rcpp::NumericMatrix Zprobsmat = eout["zprob"];
   Rcpp::NumericVector xi = eout["xi"];
   int xil = xi.size();
   Rcpp::NumericVector denom = eout["denom"];
   int denoml = denom.size();
   double nmixt = avec.size();
   Rcpp::NumericVector mas = mlogitc(avec, nmixt);
   Rcpp::Rcout << "making guess\n"; 
   int gl = ((nmixt-1) + nmixt + nmixt);
   Rcpp::NumericVector guess(gl);
   guess[Rcpp::Range(0, (nmixt-2))] = mas;
   guess[Rcpp::Range((nmixt-1), ((nmixt-1)*2))] = min(mvec);
   guess[Rcpp::Range((((nmixt-1)*2)+1), (gl-1))] = sin(svec);
   
   Rcpp::Rcout << "making zdata\n"; 
   
   int tl = (xil*nmixt);
   Rcpp::NumericVector zdata(tl);
   int count = 0;
   for(int x = 0; x < nmixt; x++) {
     for(int y = 0; y < xil; y++) {
       zdata[count] = Zprobsmat(y, x); //row, column
       count = count +1;
     }
   }

   int zrows = xil;
   int zcols = nmixt;
   
   Rcpp::Rcout << "making et\n"; 
   
   Rcpp::List et =  Rcpp::List::create(Rcpp::Named("xi") = xi, Rcpp::Named("xil") = xil, 
                                                     Rcpp::Named("zrows") = zrows, 
Rcpp::Named("zcols") = zcols,
                                                       Rcpp::Named("zdata") = zdata, Rcpp::Named("denom") = denom,
                                                       Rcpp::Named("denoml") =denoml);
    

   Rcpp::Rcout << "making guess vec\n";
   double vec[gl];
   for(int nn = 0; nn < gl; nn++){
     vec[nn] = guess[nn];
   } 

   double opar[gl];
   double Fmin = 0.0;
   int fail = 0;
   double abstol = 1.0e-8;
   double intol = 1.0e-8;
   double alpha = 1.0;
   double beta = 0.5;
   double gamma = 2.0;
   int trace =0;
   int fncount = 0;
   int maxit = 500;
   Rcpp::Rcout << "Attempting nmmin\n";
  
   nmmin(gl, vec, opar, &Fmin, 
        elnlikeB, &fail, abstol, intol, &et, alpha, beta, 
        gamma, trace, &fncount, maxit);


   Rcpp::List res = Rcpp::List::create(Rcpp::_["Fmin"] = Fmin, Rcpp::_["fail"]=fail);
   return(res);`
 }

Solved!

Instead of typedef struct, I defined a class:

class Ething {
public:
  double *xi;
  int xil;
  int zrows;
  int zcols;
  double *zdata;
  double *denom;
  int denoml;
  
  Ething(double *xi, int xil, int zrows, int zcols, double *zdata, double *denom, int denoml) : xi(xi), xil(xil), zrows(zrows), zcols(zcols), zdata(zdata), denom(denom), denoml(denoml) {}
};

After converting my data into the correct format, I was able to make the void *ex object equal to:

Ething et(xid, xil, zrows, zcols, zdata, denomd, denoml);

This allows you to surpass setting the memory/size when creating the object and passes the object as formatted in an easy-to-interpret manner. The full code will be available on github under mgaynor1/nQuack in a few months.