float64_t COctaveInterface::get_real() { const octave_value f=get_arg_increment(); if (!f.is_real_scalar()) SG_ERROR("Expected Scalar Float as argument %d\n", m_rhs_counter); return f.double_value(); }
float64_t CMatlabInterface::get_real() { const mxArray* f=get_arg_increment(); if (!f || !mxIsNumeric(f) || mxGetN(f)!=1 || mxGetM(f)!=1) SG_ERROR("Expected Scalar Float as argument %d\n", m_rhs_counter); return mxGetScalar(f); }
bool CRInterface::get_bool() { SEXP b=get_arg_increment(); if (b == R_NilValue || TYPEOF(b) != LGLSXP || nrows(b)!=1 || ncols(b)!=1) SG_ERROR("Expected Scalar Boolean as argument %d\n", m_rhs_counter); return INTEGER(b)[0] != 0; }
float64_t CRInterface::get_real() { SEXP f=get_arg_increment(); if (f == R_NilValue || TYPEOF(f) != REALSXP || nrows(f)!=1 || ncols(f)!=1) SG_ERROR("Expected Scalar Float as argument %d\n", m_rhs_counter); return REAL(f)[0]; }
bool COctaveInterface::get_bool() { const octave_value b=get_arg_increment(); if (b.is_bool_scalar()) return b.bool_value(); else if (b.is_real_scalar()) return (b.double_value()!=0); else SG_ERROR("Expected Scalar Boolean as argument %d\n", m_rhs_counter); return false; }
bool CMatlabInterface::get_bool() { const mxArray* b=get_arg_increment(); if (mxIsLogical(b) && mxGetN(b)==1 && mxGetM(b)==1) return mxGetLogicals(b)[0]; else if (mxIsNumeric(b)) return (mxGetScalar(b)!=0); else SG_ERROR("Expected Scalar Boolean as argument %d\n", m_rhs_counter); return false; }
int32_t CMatlabInterface::get_int() { const mxArray* i=get_arg_increment(); if (!i || !mxIsNumeric(i) || mxGetN(i)!=1 || mxGetM(i)!=1) SG_ERROR("Expected Scalar Integer as argument %d\n", m_rhs_counter); double s=mxGetScalar(i); if (s-CMath::floor(s)!=0) SG_ERROR("Expected Integer as argument %d\n", m_rhs_counter); return int32_t(s); }
int32_t COctaveInterface::get_int() { const octave_value i=get_arg_increment(); if (!i.is_real_scalar()) SG_ERROR("Expected Scalar Integer as argument %d\n", m_rhs_counter); double s=i.double_value(); if (s-CMath::floor(s)!=0) SG_ERROR("Expected Integer as argument %d\n", m_rhs_counter); return int32_t(s); }
void CRInterface::get_real_vector(float64_t*& vec, int32_t& len) { SEXP rvec=get_arg_increment(); if( TYPEOF(rvec) != REALSXP && TYPEOF(rvec) != INTSXP ) SG_ERROR("Expected Double Vector as argument %d\n", m_rhs_counter); len=LENGTH(rvec); vec=new float64_t[len]; ASSERT(vec); for (int32_t i=0; i<len; i++) vec[i]= (float64_t) REAL(rvec)[i]; }
char* CRInterface::get_string(int32_t& len) { SEXP s=get_arg_increment(); if (s == R_NilValue || TYPEOF(s) != STRSXP || Rf_length(s)!=1) SG_ERROR("Expected String as argument %d\n", m_rhs_counter); SEXPREC* rstr= STRING_ELT(s,0); const char* str= CHAR(rstr); len=LENGTH(rstr); ASSERT(len>0); char* res=new char[len+1]; memcpy(res, str, len*sizeof(char)); res[len]='\0'; return res; }
void CRInterface::get_int_vector(int32_t*& vec, int32_t& len) { vec=NULL; len=0; SEXP rvec=get_arg_increment(); if( TYPEOF(rvec) != INTSXP ) SG_ERROR("Expected Integer Vector as argument %d\n", m_rhs_counter); len=LENGTH(rvec); vec=new int32_t[len]; ASSERT(vec); for (int32_t i=0; i<len; i++) vec[i]= (int32_t) INTEGER(rvec)[i]; }
char* COctaveInterface::get_string(int32_t& len) { const octave_value s=get_arg_increment(); if (!s.is_string()) SG_ERROR("Expected String as argument %d\n", m_rhs_counter); std::string std_str=s.string_value(); const char* str= std_str.c_str(); len=std_str.length(); ASSERT(str && len>0); char* cstr=new char[len+1]; memcpy(cstr, str, len+1); cstr[len]='\0'; return cstr; }
void CRInterface::get_real_matrix(float64_t*& matrix, int32_t& num_feat, int32_t& num_vec) { SEXP feat=get_arg_increment(); if( TYPEOF(feat) != REALSXP && TYPEOF(feat) != INTSXP ) SG_ERROR("Expected Double Matrix as argument %d\n", m_rhs_counter); num_vec = ncols(feat); num_feat = nrows(feat); matrix=new float64_t[num_vec*num_feat]; ASSERT(matrix); for (int32_t i=0; i<num_vec; i++) { for (int32_t j=0; j<num_feat; j++) matrix[i*num_feat+j]= (float64_t) REAL(feat)[i*num_feat+j]; } }
int32_t CRInterface::get_int() { SEXP i=get_arg_increment(); if (i == R_NilValue || nrows(i)!=1 || ncols(i)!=1) SG_ERROR("Expected Scalar Integer as argument %d\n", m_rhs_counter); if (TYPEOF(i) == REALSXP) { double d=REAL(i)[0]; if (d-CMath::floor(d)!=0) SG_ERROR("Expected Integer as argument %d\n", m_rhs_counter); return (int32_t) d; } if (TYPEOF(i) != INTSXP) SG_ERROR("Expected Scalar Integer as argument %d\n", m_rhs_counter); return INTEGER(i)[0]; }
char* CMatlabInterface::get_string(int32_t& len) { bool zero_terminate=true; const mxArray* s=get_arg_increment(); if ( !(mxIsChar(s)) || (mxGetM(s)!=1) ) SG_ERROR("Expected String as argument %d\n", m_rhs_counter); len=mxGetN(s); char* string=NULL; if (zero_terminate) string=new char[len+1]; else string=new char[len]; mxChar* c=mxGetChars(s); ASSERT(c); for (int32_t i=0; i<len; i++) string[i]= (char) (c[i]); if (zero_terminate) string[len]='\0'; return string; }
void COctaveInterface::get_real_sparsematrix(SGSparseVector<float64_t>*& matrix, int32_t& num_feat, int32_t& num_vec) { const octave_value mat_feat=get_arg_increment(); if (!mat_feat.is_sparse_type() || !(mat_feat.is_double_type())) SG_ERROR("Expected Sparse Double Matrix as argument %d\n", m_rhs_counter); SparseMatrix sm = mat_feat.sparse_matrix_value (); num_vec=sm.cols(); num_feat=sm.rows(); int64_t nnz=sm.nelem(); matrix=new SGSparseVector<float64_t>[num_vec]; int64_t offset=0; for (int32_t i=0; i<num_vec; i++) { int32_t len=sm.cidx(i+1)-sm.cidx(i); matrix[i].vec_index=i; matrix[i].num_feat_entries=len; if (len>0) { matrix[i].features=new SGSparseVectorEntry<float64_t>[len]; for (int32_t j=0; j<len; j++) { matrix[i].features[j].entry=sm.data(offset); matrix[i].features[j].feat_index=sm.ridx(offset); offset++; } } else matrix[i].features=NULL; } ASSERT(offset=nnz); }
void CRInterface::get_char_string_list(TString<char>*& strings, int32_t& num_str, int32_t& max_string_len) { SEXP strs=get_arg_increment(); if (strs == R_NilValue || TYPEOF(strs) != STRSXP) SG_ERROR("Expected String List as argument %d\n", m_rhs_counter); SG_DEBUG("nrows=%d ncols=%d Rf_length=%d\n", nrows(strs), ncols(strs), Rf_length(strs)); if (nrows(strs) && ncols(strs)!=1) { num_str = ncols(strs); max_string_len = nrows(strs); strings=new TString<char>[num_str]; ASSERT(strings); for (int32_t i=0; i<num_str; i++) { char* dst=new char[max_string_len+1]; for (int32_t j=0; j<max_string_len; j++) { SEXPREC* s= STRING_ELT(strs,i*max_string_len+j); if (LENGTH(s)!=1) SG_ERROR("LENGTH(s)=%d != 1, nrows(strs)=%d ncols(strs)=%d\n", LENGTH(s), nrows(strs), ncols(strs)); dst[j]=CHAR(s)[0]; } strings[i].string=dst; strings[i].string[max_string_len]='\0'; strings[i].length=max_string_len; } } else { max_string_len=0; num_str=Rf_length(strs); strings=new TString<char>[num_str]; ASSERT(strings); for (int32_t i=0; i<num_str; i++) { SEXPREC* s= STRING_ELT(strs,i); char* c= (char*) CHAR(s); int32_t len=LENGTH(s); if (len && c) { char* dst=new char[len+1]; strings[i].string=(char*) memcpy(dst, c, len*sizeof(char)); strings[i].string[len]='\0'; strings[i].length=len; max_string_len=CMath::max(max_string_len, len); } else { SG_WARNING( "string with index %d has zero length\n", i+1); strings[i].string=0; strings[i].length=0; } } } }