static SEXP Julia_R_MD_NA_DataFrame(jl_value_t *Var)
{
SEXP ans, names, rownames;
char evalcmd[evalsize];
int i;
const char *dfname = "DataFrameName0tmp";
jl_set_global(jl_main_module, jl_symbol(dfname), (jl_value_t *)Var);
//Get Frame cols
snprintf(evalcmd, evalsize, "size(%s,2)", dfname);
jl_value_t *cols = jl_eval_string(evalcmd);
int collen = jl_unbox_long(cols);
jl_value_t *eachcolvector;
jl_value_t *coltype;
//Create VECSXP
//Create SEXP for Each Column and assign
PROTECT(ans = allocVector(VECSXP, collen));
for (i = 0; i < collen; i++)
{
snprintf(evalcmd, evalsize, "%s[%d]", dfname, i + 1);
eachcolvector = jl_eval_string(evalcmd);
snprintf(evalcmd, evalsize, "isa(%s[%d],PooledDataArray)", dfname, i + 1);
coltype = jl_eval_string(evalcmd);
if (jl_unbox_bool(coltype))
SET_VECTOR_ELT(ans, i, Julia_R_MD_NA_Factor(eachcolvector));
else
SET_VECTOR_ELT(ans, i, Julia_R_MD_NA(eachcolvector));
}
//set names attribute
snprintf(evalcmd, evalsize, "names(%s)", dfname);
jl_value_t *ret = jl_eval_string(evalcmd);
jl_value_t *onesymbol;
if (jl_is_array(ret))
{
PROTECT(names = allocVector(STRSXP, collen));
for (i = 0; i < jl_array_len(ret); i++)
{
onesymbol = jl_arrayref((jl_array_t *)ret, i);
if (jl_is_symbol(onesymbol))
SET_STRING_ELT(names, i, mkChar(((jl_sym_t *)onesymbol)->name));
}
setAttrib(ans, R_NamesSymbol, names);
UNPROTECT(1);
}
//set row names
snprintf(evalcmd, evalsize, "size(%s,1)", dfname);
jl_value_t *rows = jl_eval_string(evalcmd);
int rowlen = jl_unbox_long(rows);
PROTECT(rownames = allocVector(INTSXP, rowlen));
for (i = 0; i < rowlen; i++)
INTEGER(rownames)[i] = i + 1;
setAttrib(ans, R_RowNamesSymbol, rownames);
UNPROTECT(1);
//set class as data frame
setAttrib(ans, R_ClassSymbol, mkString("data.frame"));
//SET_OBJECT(ans, 1) ;
UNPROTECT(1);
return ans;
}
SEXP jr_data_array(jl_value_t *tt) {
SEXP ans = R_NilValue;
jl_function_t *func = jl_get_function(jl_base_module, "getindex");
jl_value_t *u = jl_get_nth_field(tt, 0);
jl_value_t *v = jl_get_nth_field(tt, 1);
JL_GC_PUSH2(&u, &v);
size_t len = jl_array_len(u);
ans = jr_array(u);
int ty = TYPEOF(ans);
for(size_t i=0; i<len; i++){
if (jl_unbox_bool(jl_call2(func, v, jl_box_long(i+1)))){
switch(ty) {
case LGLSXP:
LOGICAL(ans)[i] = NA_LOGICAL;
break;
case INTSXP:
INTEGER(ans)[i] = NA_INTEGER;
break;
case REALSXP:
REAL(ans)[i] = NA_REAL;
break;
case STRSXP:
SET_STRING_ELT(ans, i, NA_STRING);
break;
default:
LOGICAL(ans)[i] = NA_LOGICAL;
}
}
}
JL_GC_POP();
return ans;
}
//Maybe try to use cpp stuff to get the output inside julia system (ccall,cgen and cgutils)
//-| TODO: after adding in the jlapi.c jl_is_<C_type> functions replace the strcmp!
SEXP jl_value_to_SEXP(jl_value_t *res) {
size_t i=0,nd,d;
SEXP resR;
SEXPTYPE aryTyR;
jl_value_t *tmp;
char *resTy, *aryTy, *aryTy2;
if(res!=NULL) { //=> get a result
resTy=(char*)jl_typeof_str(res);
//DANGEROUS?? printf("typeof=%s\n",jl_typeof_str(res));
if(strcmp(jl_typeof_str(res),"Int64")==0 || strcmp(jl_typeof_str(res),"Int32")==0)
//if(jl_is_long(res)) //does not work because of DLLEXPORT
{
//printf("elt=%d\n",jl_unbox_long(res));
PROTECT(resR=NEW_INTEGER(1));
INTEGER_POINTER(resR)[0]=jl_unbox_long(res);
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"Float64")==0)
//if(jl_is_float64(res))
{
PROTECT(resR=NEW_NUMERIC(1));
NUMERIC_POINTER(resR)[0]=jl_unbox_float64(res);
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"Float32")==0)
//if(jl_is_float64(res))
{
PROTECT(resR=NEW_NUMERIC(1));
NUMERIC_POINTER(resR)[0]=jl_unbox_float32(res);
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"Bool")==0)
//if(jl_is_bool(res))
{
PROTECT(resR=NEW_LOGICAL(1));
LOGICAL(resR)[0]=(jl_unbox_bool(res) ? TRUE : FALSE);
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"DataType")==0)
//if(jl_is_bool(res))
{
PROTECT(resR=NEW_CHARACTER(1));
CHARACTER_POINTER(resR)[0]=mkChar(jl_typename_str(res));
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"Nothing")==0)
//if(jl_is_bool(res))
{
return R_NilValue;
}
else
if(strcmp(resTy,"Complex")==0)
//if(jl_is_bool(res))
{
tmp=(jl_value_t*)jl_get_field(res, "re");
PROTECT(resR=NEW_COMPLEX(1));
if(strcmp(jl_typeof_str(tmp),"Float64")==0) {
COMPLEX(resR)[0].r=jl_unbox_float64(tmp);
COMPLEX(resR)[0].i=jl_unbox_float64(jl_get_field(res, "im"));
} else if(strcmp(jl_typeof_str(tmp),"Int64")==0) {
COMPLEX(resR)[0].r=jl_unbox_long(tmp);
COMPLEX(resR)[0].i=jl_unbox_long(jl_get_field(res, "im"));
}
UNPROTECT(1);
return resR;
}
else
if(strcmp(resTy,"Regex")==0)
//if(jl_is_bool(res))
{
// call=(jl_function_t*)jl_get_global(jl_base_module, jl_symbol("show"));
// printf("ici\n");
// if (call) tmp=jl_call1(call,res);
// else printf("call failed!\n");
// printf("ici\n");
// resR = jl_value_to_VALUE(jl_get_field(res, "pattern"));
// return resR;
}
else
if(strcmp(resTy,"ASCIIString")==0 || strcmp(resTy,"UTF8String")==0)
{
PROTECT(resR=NEW_CHARACTER(1));
CHARACTER_POINTER(resR)[0]=mkChar(jl_bytestring_ptr(res));
UNPROTECT(1);
return resR;
}
else
if(strcmp(jl_typeof_str(res),"Tuple")==0 )
//if(jl_is_array(res))
{
d=jl_nfields(res); //BEFORE 0.3: d=jl_tuple_len(res);
PROTECT(resR=allocVector(VECSXP,d));
for(i=0;i<d;i++) {
//BEFORE 0.3: SET_ELEMENT(resR,i,jl_value_to_SEXP(jl_tupleref(res,i)));
SET_ELEMENT(resR,i,jl_value_to_SEXP(jl_fieldref(res,i)));
}
UNPROTECT(1);
return resR;
}
if(strcmp(resTy,"Array")==0)
//if(jl_is_array(res))
{
nd = jl_array_rank(res);
//Rprintf("array_ndims=%d\n",(int)nd);
aryTy=(char*)jl_typename_str(jl_array_eltype(res));
aryTy2=(char*)jl_typeof_str(jl_array_eltype(res));
//Rprintf("type elt=%s,%s\n",aryTy,(char*)jl_typeof_str(jl_array_eltype(res)));
if(strcmp(aryTy2,"DataType")!=0) return R_NilValue;
if(strcmp(aryTy,"ASCIIString")==0 || strcmp(aryTy,"UTF8String")==0) aryTyR=STRSXP;
else if(strcmp(aryTy,"Int64")==0 || strcmp(aryTy,"Int32")==0) aryTyR=INTSXP;
else if(strcmp(aryTy,"Bool")==0) aryTyR=LGLSXP;
else if(strcmp(aryTy,"Complex")==0) aryTyR=CPLXSXP;
else if(strcmp(aryTy,"Float64")==0 || strcmp(aryTy,"Float32")==0) aryTyR=REALSXP;
else aryTyR=VECSXP;
if(nd==1) {//Vector
d = jl_array_size(res, 0);
//Rprintf("array_dim[1]=%d\n",(int)d);
PROTECT(resR=allocVector(aryTyR,d));
for(i=0;i<d;i++) {
switch(aryTyR) {
case STRSXP:
SET_STRING_ELT(resR,i,mkChar(jl_bytestring_ptr(jl_arrayref((jl_array_t *)res,i))));
break;
case INTSXP:
INTEGER(resR)[i]=jl_unbox_long(jl_arrayref((jl_array_t *)res,i));
break;
case LGLSXP:
LOGICAL(resR)[i]=(jl_unbox_bool(jl_arrayref((jl_array_t *)res,i)) ? TRUE : FALSE);
break;
case REALSXP:
REAL(resR)[i]=jl_unbox_float64(jl_arrayref((jl_array_t *)res,i));
break;
case CPLXSXP:
tmp=(jl_value_t*)jl_get_field(jl_arrayref((jl_array_t *)res,i), "re");
if(strcmp(jl_typeof_str(tmp),"Float64")==0) {
COMPLEX(resR)[i].r=jl_unbox_float64(tmp);
COMPLEX(resR)[i].i=jl_unbox_float64(jl_get_field(jl_arrayref((jl_array_t *)res,i), "im"));
} else if(strcmp(jl_typeof_str(tmp),"Int64")==0) {
COMPLEX(resR)[i].r=jl_unbox_long(tmp);
COMPLEX(resR)[i].i=jl_unbox_long(jl_get_field(jl_arrayref((jl_array_t *)res,i), "im"));
}
break;
case VECSXP:
SET_ELEMENT(resR,i,jl_value_to_SEXP(jl_arrayref((jl_array_t *)res,i)));
}
}
UNPROTECT(1);
return resR;
}
//TODO: multidim array ruby equivalent???? Is it necessary
}
return R_NilValue;
/*PROTECT(resR=NEW_CHARACTER(1));
CHARACTER_POINTER(resR)[0]=mkChar(jl_typeof_str(res));
// resR=rb_str_new2("__unconverted(");
// rb_str_cat2(resR, jl_typeof_str(res));
// rb_str_cat2(resR, ")__\n");
UNPROTECT(1);
//printf("%s\n",jl_bytestring_ptr(jl_eval_string("\"$(ans)\"")));
return resR;*/
}
//=> No result (command incomplete or syntax error)
// jlapi_print_stderr(); //If this happens but this is really not sure!
// resR=rb_str_new2("__incomplete");
// if(jl_exception_occurred()!=NULL) {
// rb_str_cat2(resR, "(");
// rb_str_cat2(resR,jl_typeof_str(jl_exception_occurred()));
// jl_value_t* err=jl_get_field(jl_exception_occurred(),"msg");
// if(err!=NULL) printf("%s: %s\n",jl_typeof_str(jl_exception_occurred()),jl_bytestring_ptr(err));
// jl_exception_clear();
// rb_str_cat2(resR, ")");
// }
// rb_str_cat2(resR, "__");
return R_NilValue;//resR;
}
static SEXP Julia_R_Scalar(jl_value_t *Var)
{
SEXP ans = R_NilValue;
double tmpfloat;
//most common type is here
if (jl_is_int32(Var))
{
PROTECT(ans = ScalarInteger(jl_unbox_int32(Var)));
UNPROTECT(1);
}
else if (jl_is_int64(Var))
{
tmpfloat=(double)jl_unbox_int64(Var);
if (inInt32Range(tmpfloat))
PROTECT(ans = ScalarInteger((int32_t)jl_unbox_int64(Var)));
else
PROTECT(ans = ScalarReal(tmpfloat));
UNPROTECT(1);
}
//more integer type
if (jl_is_uint32(Var))
{
tmpfloat=(double)jl_unbox_uint32(Var);
if (inInt32Range(tmpfloat))
PROTECT(ans = ScalarInteger((int32_t)jl_unbox_uint32(Var)));
else
PROTECT(ans = ScalarReal(tmpfloat));
UNPROTECT(1);
}
else if (jl_is_uint64(Var))
{
tmpfloat=(double)jl_unbox_int64(Var);
if (inInt32Range(tmpfloat))
PROTECT(ans = ScalarInteger((int32_t)jl_unbox_uint64(Var)));
else
PROTECT(ans = ScalarReal(tmpfloat));
UNPROTECT(1);
}
else if (jl_is_float64(Var))
{
PROTECT(ans = ScalarReal(jl_unbox_float64(Var)));
UNPROTECT(1);
}
else if (jl_is_float32(Var))
{
PROTECT(ans = ScalarReal(jl_unbox_float32(Var)));
UNPROTECT(1);
}
else if (jl_is_bool(Var))
{
PROTECT(ans = ScalarLogical(jl_unbox_bool(Var)));
UNPROTECT(1);
}
else if (jl_is_int8(Var))
{
PROTECT(ans = ScalarInteger(jl_unbox_int8(Var)));
UNPROTECT(1);
}
else if (jl_is_uint8(Var))
{
PROTECT(ans = ScalarInteger(jl_unbox_uint8(Var)));
UNPROTECT(1);
}
else if (jl_is_int16(Var))
{
PROTECT(ans = ScalarInteger(jl_unbox_int16(Var)));
UNPROTECT(1);
}
else if (jl_is_uint16(Var))
{
PROTECT(ans = ScalarInteger(jl_unbox_uint16(Var)));
UNPROTECT(1);
}
else if (jl_is_utf8_string(Var))
{
PROTECT(ans = allocVector(STRSXP, 1));
SET_STRING_ELT(ans, 0, mkCharCE(jl_string_data(Var), CE_UTF8));
UNPROTECT(1);
}
else if (jl_is_ascii_string(Var))
{
PROTECT(ans = ScalarString(mkChar(jl_string_data(Var))));
UNPROTECT(1);
}
return ans;
}
// adapted from https://github.com/armgong/RJulia/blob/master/src/R_Julia.c
SEXP jr_scalar(jl_value_t *tt)
{
SEXP ans = R_NilValue;
double z;
// float64, int64, int32 are most common, so put them in the front
if (jl_is_float64(tt))
{
PROTECT(ans = Rf_ScalarReal(jl_unbox_float64(tt)));
UNPROTECT(1);
}
else if (jl_is_int32(tt))
{
PROTECT(ans = Rf_ScalarInteger(jl_unbox_int32(tt)));
UNPROTECT(1);
}
else if (jl_is_int64(tt))
{
z = (double)jl_unbox_int64(tt);
if (in_int32_range(z))
PROTECT(ans = Rf_ScalarInteger((int32_t)jl_unbox_int64(tt)));
else
PROTECT(ans = Rf_ScalarReal(z));
UNPROTECT(1);
}
else if (jl_is_bool(tt))
{
PROTECT(ans = Rf_ScalarLogical(jl_unbox_bool(tt)));
UNPROTECT(1);
}
else if (jl_is_int8(tt))
{
PROTECT(ans = Rf_ScalarInteger(jl_unbox_int8(tt)));
UNPROTECT(1);
}
else if (jl_is_uint8(tt))
{
PROTECT(ans = Rf_ScalarInteger(jl_unbox_uint8(tt)));
UNPROTECT(1);
}
else if (jl_is_int16(tt))
{
PROTECT(ans = Rf_ScalarInteger(jl_unbox_int16(tt)));
UNPROTECT(1);
}
else if (jl_is_uint16(tt))
{
PROTECT(ans = Rf_ScalarInteger(jl_unbox_uint16(tt)));
UNPROTECT(1);
}
else if (jl_is_uint32(tt))
{
z = (double)jl_unbox_uint32(tt);
if (in_int32_range(z))
PROTECT(ans = Rf_ScalarInteger((int32_t)jl_unbox_uint32(tt)));
else
PROTECT(ans = Rf_ScalarReal(z));
UNPROTECT(1);
}
else if (jl_is_uint64(tt))
{
z = (double)jl_unbox_int64(tt);
if (in_int32_range(z))
PROTECT(ans = Rf_ScalarInteger((int32_t)jl_unbox_uint64(tt)));
else
PROTECT(ans = Rf_ScalarReal(z));
UNPROTECT(1);
}
else if (jl_is_float32(tt))
{
PROTECT(ans = Rf_ScalarReal(jl_unbox_float32(tt)));
UNPROTECT(1);
}
else if (jl_is_utf8_string(tt))
{
PROTECT(ans = Rf_allocVector(STRSXP, 1));
SET_STRING_ELT(ans, 0, Rf_mkCharCE(jl_string_data(tt), CE_UTF8));
UNPROTECT(1);
}
else if (jl_is_ascii_string(tt))
{
PROTECT(ans = Rf_ScalarString(Rf_mkChar(jl_string_data(tt))));
UNPROTECT(1);
}
return ans;
}
template <> inline bool unbox<bool>(jl_value_t* val) { JULIACPP_ASSERT_NOMSG(jl_is_bool(val)); return (bool)jl_unbox_bool(val); }
