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;
}
}
}
}
