04/07/14 fWHtrans.

cpp 1
/home/gauss/fWHtrans.cpp
/*=================================================================
* Este cdigo calcula la transformada rpida discreta Walsh-Hadamard
*
* Basado en el cdigo de Chengbo Li, Rice University para Matlab
*
* Alejandro R. Urza Pineda
* Instituto de Ciencias Nucleares, UNAM
* 2 de Julio de 2014
*
*=================================================================*/
#include <math.h>
#include "mex.h"
#include "matrix.h"
//#include <stdlib.h>
//#include <malloc.h>
//#include <stack>
#if !defined(MAX)
#define MAX(A, B) ((A) > (B) ? (A) : (B))
#endif
#if !defined(MIN)
#define MIN(A, B) ((A) < (B) ? (A) : (B))
#endif
/*Entrada al cdigo*/
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray*prhs[] )

{
int p, nStage, L, flag;
int i, j, m, n, N, J, K, M;
double *v_in, *v_out, *v_ext, *v_final, *temp;

if (nrhs != 1) {
mexErrMsgTxt("Slo un argumento de entrada es requerido.");
}
else if (nlhs > 1) {
mexErrMsgTxt("Demasiados argumentos.");
}

m = mxGetM(prhs[0]);
n = mxGetN(prhs[0]);
if (MIN(m,n) != 1) {
mexErrMsgTxt("Slo vectores son admitidos.");
}
/* flag == 1, vector fila; flag == 0, vector columna. */
flag = 1;
if ( m != 1) {
flag = 0;
}

n = MAX(m,n);
p = (int) ceil(log((double)n)/log(2.0));
N = 1 << p; // pow(2, p)
// sqrtN = sqrt(N);
04/07/14 fWHtrans.cpp 2
/home/gauss/fWHtrans.cpp
if ( flag == 1) {
plhs[0] = mxCreateDoubleMatrix(1, N, mxREAL);
}
else {
plhs[0] = mxCreateDoubleMatrix(N, 1, mxREAL);
}
v_final = mxGetPr(plhs[0]);
v_in = mxGetPr(prhs[0]);
v_ext = (double*) mxCalloc (N,sizeof(double));
v_out = (double*) mxCalloc (N,sizeof(double));
for (j = 0; j <n; j++){
v_ext[j] = v_in[j];
}
// mxDestroyArray(prhs[0]);
for (i=0; i<N-1; i = i+2) {
v_ext[i] = v_ext[i] + v_ext[i+1];
v_ext[i+1] = v_ext[i] - v_ext[i+1] * 2;
}
L = 1;

/*Secuencia principal*/
for (nStage = 2; nStage<=p; ++nStage){
M = 1 << L; // pow(2, L)
J = 0;
K = 0;
while (K<N-1){
for (j = J;j < J+M-1; j = j+2){

v_out[K] = v_ext[j] + v_ext[j+M];
v_out[K+1] = v_ext[j] - v_ext[j+M];
v_out[K+2] = v_ext[j+1] - v_ext[j+1+M];
v_out[K+3] = v_ext[j+1] + v_ext[j+1+M];
K = K+4;
}
J = J+2*M;
}
// for ( i =0; i<N; ++i){
// v_ext[i] = v_out[i];
// }
// mxFree(v_ext);
temp = v_ext;
v_ext = v_out;
v_out = temp;
// v_out = (double*) mxMalloc (N,sizeof(double));
L = L+1;
}

for ( i =0; i<N; ++i){
v_final[i] = v_ext[i]/N;
}

mxFree(v_out);
mxFree(v_ext);
04/07/14 fWHtrans.cpp 3
/home/gauss/fWHtrans.cpp
return;
}