inline
CType
CObject::GetType(void) const
{
// ???
PyObject* obj = PyObject_Type (Get());
if ( !obj ) {
throw CTypeError("Type does not exist");
}
return CType(obj, eTakeOwnership);
}
void CMyContextBase::InitContextClass(_S_MyContextBaseInfo* pInfo)
{
if(pInfo)
{
if(pInfo->methCount)
{
pInfo->pMethMap=new CBLMap;
const _S_MethDef* pDef=pInfo->pMethodDef;
for(int i=0;i<pInfo->methCount;)
{
pInfo->pMethMap->InsertKey(pDef->Names[0],i);
pInfo->pMethMap->InsertKey(pDef->Names[1],i++);
pDef++;
}
pInfo->pMethMap->Optimize();
}
if(pInfo->propCount)
{
pInfo->pPropMap=new CBLMap;
const _S_PropDef* pProp=pInfo->pPropDef;
for(int i=0;i<pInfo->propCount;)
{
pInfo->pPropMap->InsertKey(pProp->Names[0],i);
pInfo->pPropMap->InsertKey(pProp->Names[1],i++);
pProp++;
}
pInfo->pPropMap->Optimize();
}
if (pInfo->RegToCreate)
{
CBLContext::RegisterContextClass((CRuntimeClass*)pInfo->pRTC,pInfo->EngTypeString,CType(100));
CBLContext::RegisterContextClass((CRuntimeClass*)pInfo->pRTC,pInfo->RusTypeString,CType(100));
}
if(pInfo->pInitFunc)
pInfo->pInitFunc();
}
}
Message *GetMdsMsg(int id, int *status) {
MsgHdr header;
Message *msg = 0;
int msglen = 0;
//MdsSetClientAddr(0);
*status = 0;
*status = GetBytes(id, (void *)&header, sizeof(MsgHdr));
if (*status &1){
if ( Endian(header.client_type) != Endian(ClientType()) ) FlipHeader(&header);
#ifdef DEBUG
printf("msglen = %d\nstatus = %d\nlength = %d\nnargs = %d\ndescriptor_idx = %d\nmessage_id = %d\ndtype = %d\n",
header.msglen,header.status,header.length,header.nargs,header.descriptor_idx,header.message_id,header.dtype);
printf("client_type = %d\nndims = %d\n",header.client_type,header.ndims);
#endif
if (CType(header.client_type) > CRAY_CLIENT || header.ndims > MAX_DIMS)
{
DisconnectConnection(id);
fprintf(stderr,"\rGetMdsMsg shutdown connection %d: bad msg header, header.ndims=%d, client_type=%d\n",id,header.ndims,CType(header.client_type));
*status = 0;
return 0;
}
msglen = header.msglen;
msg = malloc(header.msglen);
msg->h = header;
*status = GetBytes(id, msg->bytes, msglen - sizeof(MsgHdr));
if (*status & 1 && IsCompressed(header.client_type))
{
Message *m;
unsigned long dlen;
memcpy(&msglen, msg->bytes, 4);
if (Endian(header.client_type) != Endian(ClientType()))
FlipBytes(4,(char *)&msglen);
m = malloc(msglen);
m->h = header;
dlen = msglen - sizeof(MsgHdr);
*status = uncompress(m->bytes, &dlen, msg->bytes + 4, header.msglen - sizeof(MsgHdr) - 4) == 0;
if (*status & 1)
{
m->h.msglen = msglen;
free(msg);
msg = m;
}
else
free(m);
}
if (*status & 1 && (Endian(header.client_type) != Endian(ClientType())))
FlipData(msg);
}
return msg;
}
mdsip_message_t *mdsip_get_message(void *io_handle, int *status)
{
mdsip_message_header_t header;
globus_result_t result;
mdsip_message_t *msg = NULL;
int msglen = 0;
globus_size_t nbytes;
*status = 0;
result = globus_xio_read(io_handle, (globus_byte_t *)&header, sizeof(header),sizeof(header),&nbytes, NULL);
mdsip_test_status(io_handle,result,"mdsip_get_message, globus_xio_read");
if (result != GLOBUS_SUCCESS) return NULL;
if ( Endian(header.client_type) != Endian(mdsip_client_type()) )
mdsip_flip_header(&header);
if ( CType(header.client_type) > CRAY_CLIENT || header.ndims > MAX_DIMS || header.msglen < sizeof(header))
{
globus_xio_close(io_handle,NULL);
fprintf(stderr,"ERROR: mdsip_get_message, bad message header - closing connection\n");
return NULL;
}
msglen = header.msglen;
msg = malloc(header.msglen);
msg->h = header;
if (msglen > sizeof(header))
{
result = globus_xio_read(io_handle,msg->bytes,msglen - sizeof(header),msglen - sizeof(header),&nbytes,NULL);
mdsip_test_status(io_handle,result,"mdsip_get_message, globus_xio_read");
}
if (result != GLOBUS_SUCCESS)
{
free(msg);
return NULL;
}
if (Endian(header.client_type) != Endian(mdsip_client_type()))
mdsip_flip_data(msg);
*status = 1;
return msg;
}
void ViterbiDecoder::Run() {
int DataLength, CodeLength, i, j, index;
int *g_encoder;
int nn, KK, mm, max_states, code_type, dec_type;
double elm;
float *input_c_float;
int *output_u_int;
int *out0, *out1, *state0, *state1;
///////////////////////////////////////////////
///////////////////////////////////////////////
///////////////////////////////////////////////
/* first input is the data word */
gsl_vector_class inputobj = vin1.GetDataObj();
CodeLength = inputobj.vec->size; /* number of data bits */
/* convert the input into float */
input_c_float = (float *)calloc( CodeLength, sizeof(float) );
for (i=0;i<CodeLength;i++)
input_c_float[i] = gsl_vector_get(inputobj.vec,i);
/* default values */
code_type = CType();
nn = gp_mat->size1;
KK = gp_mat->size2;
mm = KK - 1;
max_states = 1 << mm; /* 2^mm */
/* determine the DataLength */
DataLength = (CodeLength/nn)-mm;
/* Convert code polynomial to binary */
g_encoder = (int*)calloc(nn, sizeof(int) );
for (i = 0;i<nn;i++) {
for (j=0;j<KK;j++) {
elm = gsl_matrix_get(gp_mat,i,j);
if (elm != 0) {
g_encoder[i] = g_encoder[i] + (int) pow(2,(KK-j-1));
}
}
}
/* create appropriate transition matrices */
out0 = (int *)calloc( max_states, sizeof(int) );
out1 = (int *)calloc( max_states, sizeof(int) );
state0 = (int *)calloc( max_states, sizeof(int) );
state1 = (int *)calloc( max_states, sizeof(int) );
if ( code_type ) {
nsc_transit( out0, state0, 0, g_encoder, KK, nn );
nsc_transit( out1, state1, 1, g_encoder, KK, nn );
} else {
rsc_transit( out0, state0, 0, g_encoder, KK, nn );
rsc_transit( out1, state1, 1, g_encoder, KK, nn );
}
gsl_vector_uint *output = gsl_vector_uint_alloc(DataLength);
output_u_int = (int *)calloc( DataLength, sizeof(int) );
/* Run the Viterib algorithm */
Viterbi( output_u_int, out0, state0, out1, state1,
input_c_float, KK, nn, DataLength );
/* cast to outputs */
for (j=0;j<DataLength;j++) {
gsl_vector_uint_set(output,j,output_u_int[j]);
}
gsl_vector_uint_class outobj(output);
// outobj.show();
vout1.DeliverDataObj(outobj);
///////////////////////////////////////////////
///////////////////////////////////////////////
///////////////////////////////////////////////
/* Clean up memory */
free( out0 );
free( out1 );
free( state0 );
free( state1 );
free( g_encoder );
free( input_c_float );
free( output_u_int );
gsl_vector_uint_free(output);
}
inline Mat< CType(RType) > asMat(Rcpp::Matrix<RType>& m){
return Mat< CType(RType) >(m.begin(), m.nrow(), m.ncol());
}
inline Vec< CType(RType) > asVec(Rcpp::Vector<RType>& v){
return Vec< CType(RType) >(v.begin(), v.length());
}
