// * The body of REXLANG algorithm *
// The main procedure is executed once in each sampling period.
long main(void)
{
if (hCom<0)
{
hCom = OpenUDP(0, receiverPort, 0, 0); //opening UDP socket, syntax long OpenUDP(string localname, long lclPort, string remotename, long remPort)
}
else
{
//receive the data
dataCnt = Recv(hCom,buffer,BUFFER_SIZE); //receive data, max number of bytes = BUFFER_SIZE
//the first signal is of type long, therefore 4 bytes
signal0 = buffer[0] | buffer[1]<<8 | buffer[2]<<16 | buffer[3]<<24;
dat0 = buffer[0];
dat1 = buffer[1];
dat2 = buffer[2];
dat3 = buffer[3];
//the second signal is binary, therefore 1 byte
signal1 = buffer[4];
//the third signal is of type double, therefore 8 bytes will be processed
signal2 = buf2double(subarray(5,buffer),1);
//the fourth signal is of type double, therefore 8 bytes will be processed
signal3 = buf2double(subarray(13,buffer),1);
}
//publishing the UDP communication handle through output signal (for debugging)
handle = hCom;
//and also the number of received bytes
receivedBytes = dataCnt;
return 0;
}
static void whittle2 (Array acf, Array Aold, Array Bold, int lag,
char *direction, Array A, Array K, Array E)
{
int d, i, nser=DIM(acf)[1];
const void *vmax;
Array beta, tmp, id;
d = strcmp(direction, "forward") == 0;
vmax = vmaxget();
beta = make_zero_matrix(nser,nser);
tmp = make_zero_matrix(nser, nser);
id = make_identity_matrix(nser);
set_array_to_zero(E);
copy_array(id, subarray(A,0));
for(i = 0; i < lag; i++) {
matrix_prod(subarray(acf,lag - i), subarray(Aold,i), d, 1, tmp);
array_op(beta, tmp, '+', beta);
matrix_prod(subarray(acf,i), subarray(Bold,i), d, 1, tmp);
array_op(E, tmp, '+', E);
}
qr_solve(E, beta, K);
transpose_matrix(K,K);
for (i = 1; i <= lag; i++) {
matrix_prod(K, subarray(Bold,lag - i), 0, 0, tmp);
array_op(subarray(Aold,i), tmp, '-', subarray(A,i));
}
vmaxset(vmax);
}
static void subarray(size_t size, int n_dim, int n_ptr,
void ***prev, void **start, int *dimension, int index){
int i, dim = dimension[index];
if(n_dim>0){ // Set up pointers to pointers
for(i=0; i<n_ptr; i++) prev[i] = start + i*dim;
subarray(size, n_dim-1, n_ptr*dim,
(void***)start, // Pointers to be initialised
start+n_ptr*dim, // Pointing to locations starting here
dimension, index+1);
}else{ // Last recursion; set up pointers to data
// The data should lie on a 'align'-byte boundary, so, if necessary,
// we move 'start' to the next 'align'-byte boundary.
// We allocated additional space for this using 'align_pad' in amalloc.
if(0!=(long)start%alignment)
start = (void**)(((long)start/alignment+1)*alignment);
for(i=0; i<n_ptr; i++){
char **previ = (char**)&prev[i];
*previ = (char*)start+i*dim*size;
}
}
}
static void whittle(Array acf, int nlag, Array *A, Array *B, Array p_forward,
Array v_forward, Array p_back, Array v_back)
{
int lag, nser = DIM(acf)[1];
const void *vmax;
Array EA, EB; /* prediction variance */
Array KA, KB; /* partial correlation coefficient */
Array id, tmp;
vmax = vmaxget();
KA = make_zero_matrix(nser, nser);
EA = make_zero_matrix(nser, nser);
KB = make_zero_matrix(nser, nser);
EB = make_zero_matrix(nser, nser);
id = make_identity_matrix(nser);
copy_array(id, subarray(A[0],0));
copy_array(id, subarray(B[0],0));
copy_array(id, subarray(p_forward,0));
copy_array(id, subarray(p_back,0));
for (lag = 1; lag <= nlag; lag++) {
whittle2(acf, A[lag-1], B[lag-1], lag, "forward", A[lag], KA, EB);
whittle2(acf, B[lag-1], A[lag-1], lag, "back", B[lag], KB, EA);
copy_array(EA, subarray(v_forward,lag-1));
copy_array(EB, subarray(v_back,lag-1));
copy_array(KA, subarray(p_forward,lag));
copy_array(KB, subarray(p_back,lag));
}
tmp = make_zero_matrix(nser,nser);
matrix_prod(KB,KA, 1, 1, tmp);
array_op(id, tmp, '-', tmp);
matrix_prod(EA, tmp, 0, 0, subarray(v_forward, nlag));
vmaxset(vmax);
}
void *pt_amalloc(void* (*allocator)(size_t, const char *vname,
const char *fname, const char *cname),
size_t size, int n_dim, ...){
/*
The first bit of data in the array are pointers which point to the data
in the next dimension, which are pointers to data in the next dimension,
and so on, until the penultimate dimension, where the pointers point to
the actual data.
*/
int *dimension = (int*)malloc(n_dim*sizeof(int));
// Count the pointers and data elements in the array.
va_list ap;
va_start(ap, n_dim);
int d, n_ptr = 0, n_data = 1;
for(d = 0; d<n_dim; d++){
dimension[d] = va_arg(ap, int);
n_data *= dimension[d];
if(d<n_dim-1) n_ptr += n_data;
}
va_end(ap);
// Allocate the memory for the data and the pointers.
// The allocator will align the pointers correctly. We should
// align the data on a boundary which is a multiple of 128 bytes so let's
// pad the array so there is space to realign the data if necessary.
// if the size of all the pointers happens to be a multiple of the
//alignment length then no padding is necessary here, right?
size_t align;
if(n_ptr*sizeof(void*)%alignment==0) align = 0;
else align = alignment;
void **start = (void**)allocator(n_data*size+align+n_ptr*sizeof(void*),"","amalloc","");
// Set up the pointers.
void **p;
subarray(size, n_dim-1, 1, &p, start, dimension, 0);
// VRB.Smalloc("","amalloc","", start, n_data*size+align+n_ptr*sizeof(void*));
free(dimension);
return (void*)start;
}
void multi_yw(double *acf, int *pn, int *pomax, int *pnser, double *coef,
double *pacf, double *var, double *aic, int *porder, int *useaic)
{
int i, m;
int omax = *pomax, n = *pn, nser=*pnser, order=*porder;
double aicmin;
Array acf_array, p_forward, p_back, v_forward, v_back;
Array *A, *B;
int dim[3];
dim[0] = omax+1; dim[1] = dim[2] = nser;
acf_array = make_array(acf, dim, 3);
p_forward = make_array(pacf, dim, 3);
v_forward = make_array(var, dim, 3);
/* Backward equations (discarded) */
p_back= make_zero_array(dim, 3);
v_back= make_zero_array(dim, 3);
A = (Array *) R_alloc(omax+2, sizeof(Array));
B = (Array *) R_alloc(omax+2, sizeof(Array));
for (i = 0; i <= omax; i++) {
A[i] = make_zero_array(dim, 3);
B[i] = make_zero_array(dim, 3);
}
whittle(acf_array, omax, A, B, p_forward, v_forward, p_back, v_back);
/* Model order selection */
for (m = 0; m <= omax; m++) {
aic[m] = n * ldet(subarray(v_forward,m)) + 2 * m * nser * nser;
}
if (*useaic) {
order = 0;
aicmin = aic[0];
for (m = 0; m <= omax; m++) {
if (aic[m] < aicmin) {
aicmin = aic[m];
order = m;
}
}
}
else order = omax;
*porder = order;
for(i = 0; i < vector_length(A[order]); i++)
coef[i] = VECTOR(A[order])[i];
}
Mat img88Inverse_DCT(vector<Mat> vmtx, int rows, int cols,int coefficient)
{
Mat res(rows,cols,CV_8U);
res.setTo(0);
vector<Mat> inv;
for(unsigned int i=0;i<vmtx.size();i++)
{
Mat temp(8,8,CV_8U);
temp=imgInverse_2D_DCT(vmtx[i],coefficient);
inv.push_back(temp);
}
for(int i=0;i<rows/8;i++)
for(int j=0;j<cols/8;j++)
{
Mat subarray(res,Range(i*8,8+i*8),Range(j*8,8+j*8));
inv[i*rows/8+j].copyTo(subarray);
}
return res;
}
CELL * p_slice(CELL * params)
{
CELL * cell;
ssize_t offset;
ssize_t length;
params = getEvalDefault(params, &cell);
params = getInteger(params, (UINT *)&offset);
if(params != nilCell)
getInteger(params, (UINT *)&length);
else
length = MAX_LONG;
if(isList(cell->type))
return(sublist((CELL *)cell->contents, offset, length));
else if(cell->type == CELL_STRING)
return(substring((char *)cell->contents, cell->aux - 1, offset, length));
else if(cell->type == CELL_ARRAY)
return(subarray(cell, offset, length));
return(errorProcExt(ERR_LIST_OR_STRING_EXPECTED, params));
}
PassRefPtr<Int16Array> Int16Array::subarray(int begin) const
{
return subarray(begin, length());
}
PassRefPtr<Int16Array> Int16Array::subarray(int start) const
{
return subarray(start, length());
}
static void burg0(int omax, Array resid_f, Array resid_b, Array *A, Array *B,
Array P, Array V, int vmethod)
{
int i, j, m, n = NCOL(resid_f), nser=NROW(resid_f);
Array ss_ff, ss_bb, ss_fb;
Array resid_f_tmp, resid_b_tmp;
Array KA, KB, E;
Array id, tmp;
ss_ff = make_zero_matrix(nser, nser);
ss_fb = make_zero_matrix(nser, nser);
ss_bb = make_zero_matrix(nser, nser);
resid_f_tmp = make_zero_matrix(nser, n);
resid_b_tmp = make_zero_matrix(nser, n);
id = make_identity_matrix(nser);
tmp = make_zero_matrix(nser, nser);
E = make_zero_matrix(nser, nser);
KA = make_zero_matrix(nser, nser);
KB = make_zero_matrix(nser, nser);
set_array_to_zero(A[0]);
set_array_to_zero(B[0]);
copy_array(id, subarray(A[0],0));
copy_array(id, subarray(B[0],0));
matrix_prod(resid_f, resid_f, 0, 1, E);
scalar_op(E, n, '/', E);
copy_array(E, subarray(V,0));
for (m = 0; m < omax; m++) {
for(i = 0; i < nser; i++) {
for (j = n - 1; j > m; j--) {
MATRIX(resid_b)[i][j] = MATRIX(resid_b)[i][j-1];
}
MATRIX(resid_f)[i][m] = 0.0;
MATRIX(resid_b)[i][m] = 0.0;
}
matrix_prod(resid_f, resid_f, 0, 1, ss_ff);
matrix_prod(resid_b, resid_b, 0, 1, ss_bb);
matrix_prod(resid_f, resid_b, 0, 1, ss_fb);
burg2(ss_ff, ss_bb, ss_fb, E, KA, KB); /* Update K */
for (i = 0; i <= m + 1; i++) {
matrix_prod(KA, subarray(B[m], m + 1 - i), 0, 0, tmp);
array_op(subarray(A[m], i), tmp, '-', subarray(A[m+1], i));
matrix_prod(KB, subarray(A[m], m + 1 - i), 0, 0, tmp);
array_op(subarray(B[m], i), tmp, '-', subarray(B[m+1], i));
}
matrix_prod(KA, resid_b, 0, 0, resid_f_tmp);
matrix_prod(KB, resid_f, 0, 0, resid_b_tmp);
array_op(resid_f, resid_f_tmp, '-', resid_f);
array_op(resid_b, resid_b_tmp, '-', resid_b);
if (vmethod == 1) {
matrix_prod(KA, KB, 0, 0, tmp);
array_op(id, tmp, '-', tmp);
matrix_prod(tmp, E, 0, 0, E);
}
else if (vmethod == 2) {
matrix_prod(resid_f, resid_f, 0, 1, E);
matrix_prod(resid_b, resid_b, 0, 1, tmp);
array_op(E, tmp, '+', E);
scalar_op(E, 2.0*(n - m - 1), '/', E);
}
else error(_("Invalid vmethod"));
copy_array(E, subarray(V,m+1));
copy_array(KA, subarray(P,m+1));
}
}
void multi_burg(int *pn, double *x, int *pomax, int *pnser, double *coef,
double *pacf, double *var, double *aic, int *porder, int *useaic,
int *vmethod)
{
int i, j, m, omax = *pomax, n = *pn, nser=*pnser, order=*porder;
int dim1[3];
double aicmin;
Array xarr, resid_f, resid_b, resid_f_tmp;
Array *A, *B, P, V;
dim1[0] = omax+1; dim1[1] = dim1[2] = nser;
A = (Array *) R_alloc(omax+1, sizeof(Array));
B = (Array *) R_alloc(omax+1, sizeof(Array));
for (i = 0; i <= omax; i++) {
A[i] = make_zero_array(dim1, 3);
B[i] = make_zero_array(dim1, 3);
}
P = make_array(pacf, dim1, 3);
V = make_array(var, dim1, 3);
xarr = make_matrix(x, nser, n);
resid_f = make_zero_matrix(nser, n);
resid_b = make_zero_matrix(nser, n);
set_array_to_zero(resid_b);
copy_array(xarr, resid_f);
copy_array(xarr, resid_b);
resid_f_tmp = make_zero_matrix(nser, n);
burg0(omax, resid_f, resid_b, A, B, P, V, *vmethod);
/* Model order selection */
for (i = 0; i <= omax; i++) {
aic[i] = n * ldet(subarray(V,i)) + 2 * i * nser * nser;
}
if (*useaic) {
order = 0;
aicmin = aic[0];
for (i = 1; i <= omax; i++) {
if (aic[i] < aicmin) {
aicmin = aic[i];
order = i;
}
}
}
else order = omax;
*porder = order;
for(i = 0; i < vector_length(A[order]); i++)
coef[i] = VECTOR(A[order])[i];
if (*useaic) {
/* Recalculate residuals for chosen model */
set_array_to_zero(resid_f);
set_array_to_zero(resid_f_tmp);
for (m = 0; m <= order; m++) {
for (i = 0; i < NROW(resid_f_tmp); i++) {
for (j = 0; j < NCOL(resid_f_tmp) - order; j++) {
MATRIX(resid_f_tmp)[i][j + order] = MATRIX(xarr)[i][j + order - m];
}
}
matrix_prod(subarray(A[order],m), resid_f_tmp, 0, 0, resid_f_tmp);
array_op(resid_f_tmp, resid_f, '+', resid_f);
}
}
copy_array(resid_f, xarr);
}
