00001 /**********************************************************/ 00002 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/ 00003 /* 00004 Copyright: 1994 - Grupo de Voz (DAET) ETSII/IT-Bilbao 00005 00006 Nombre fuente................ SPL4.C 00007 Nombre paquete............... SPL 00008 Lenguaje fuente.............. C (Borland C/C++ 3.1) 00009 Estado....................... Completado 00010 Dependencia Hard/OS.......... - 00011 Codigo condicional........... NDEBUG 00012 00013 Codificacion................. Borja Etxebarria 00014 00015 Version dd/mm/aa Autor Proposito de la edicion 00016 ------- -------- -------- ----------------------- 00017 1.1.4 16/05/96 Borja bugs en algunos valores de retorno 00018 1.1.3 15/05/96 Borja bugs en documentacion 00019 1.1.2 30/07/95 Borja scope funciones explicito 00020 1.1.1 14/04/95 Borja correccion nombres funciones nel_?() e idx_?() 00021 1.1.0 08/12/94 Borja revision general (tipos,idx,nel,tnel...) 00022 1.0.0 06/07/93 Borja Codificacion inicial. 00023 00024 ======================== Contenido ======================== 00025 Autocorrelacion, covarianza, y covarianzas modificadas. 00026 Delante de cada grupo de funciones de comenta detalladamente 00027 el contenido. 00028 00029 Definir NDEBUG para desconectar la validacion de parametros 00030 con assert(). No definir este simbolo mientras se depuren 00031 aplicaciones, ya que aunque las funciones son algo mas lentas, 00032 el chequeo de validacion de parametros resuelve muchos problemas. 00033 =========================================================== 00034 */ 00035 /*/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\*/ 00036 /**********************************************************/ 00037 00038 #include "spli.h" 00039 00040 /**********************************************************/ 00041 /* Funciones de autocorrelacion (acorr_???) y autocorrelacion 00042 normalizada a la del origen (acorr_???_n). 00043 00044 Reciben como parametros basicos: 00045 00046 - SPL_pFLOAT {v} : vector de longitud {N} del que se quieren calcular 00047 . autocorrelaciones. 00048 - SPL_INT {N} : Longitud del vector {v}. 00049 . {N}>=0 00050 00051 Ademas reciben otros parametros: 00052 00053 * Las funciones acorr_i_? reciben: 00054 . - SPL_INT {i} : Autocorrelacion R(i) a calcular. 00055 . {i}>=0 00056 . La funcion {devuelve} R(i). 00057 00058 * Las funciones acorr_ab_? reciben: 00059 . - SPL_pFLOAT {vac}: Vector de autocorrelaciones a rellenar. 00060 . Tiene ({b}-{a}+1) elementos. 00061 . - SPL_INT {a} : Autocorrelacion inicial R(a) a calcular. 00062 . {a}>=0 00063 . - SPL_INT {b} : Autocorrelacion final R(b) a calcular. 00064 . {b}>=0; {b}>=a 00065 . La funcion calcula desde R(a) hasta R(b) y mete los resultados 00066 . en {vac}. 00067 . Por tanto este vector debe tener ({b}-{a}+1) elementos SPL_FLOAT 00068 . (este valor lo {devuelve} la funcione nel_acorr_ab(a,b) ). 00069 . La funcion {devuelve} el puntero {vac} en la version que no normaliza 00070 . las autocorrelaciones, y {devuelve} la autocorrelacion en el origen 00071 . en la version que si normaliza las autocorrelaciones. 00072 00073 Las funciones acorr_???_n normalizan el valor de las autocorrelaciones 00074 calculadas al valor de la autocorrelacion en el origen R(0). 00075 Si R(0) es nula, la normalizacion no se efectua (equivale a normalizar 00076 a R(0)=1) y la funcion {devuelve} 0.0 00077 00078 Ref: 00079 . Digital Processing of Speech Signals 00080 . L.R. Rabiner / R.W Schafer 00081 . Prentice Hall 00082 */ 00083 /**********************************************************/ 00084 /* {devuelve} la autocorrelacion {i} del vector {v} de {N} elementos. 00085 {i} debe ser positivo >= 0. {N}>=0 */ 00086 00087 PUBLIC SPL_FLOAT XAPI acorr_i( SPL_pFLOAT v, SPL_INT N, SPL_INT i ) 00088 { 00089 SPL_INT k; 00090 SPL_FLOAT sum; 00091 assert(N>=0); 00092 assert(i>=0); 00093 00094 __xsum(k,i,N,v[k]*v[k-i],sum,0.0); 00095 00096 return sum; 00097 } 00098 00099 /**********************************************************/ 00100 /* {devuelve} la autocorrelacion {i} normalizada a la autocorrelacion 00101 en el origen, del vector {v} de {N} elementos. 00102 {i} debe ser positivo >= 0. {N}>=0. 00103 Si R(0) es nula, la normalizacion no se efectua. */ 00104 00105 PUBLIC SPL_FLOAT XAPI acorr_i_n( SPL_pFLOAT v, SPL_INT N, SPL_INT i ) 00106 { 00107 SPL_INT k; 00108 SPL_FLOAT sum, r0; 00109 assert(N>=0); 00110 assert(i>=0); 00111 00112 __xsum(k,0,N,v[k]*v[k],r0,0.0); 00113 __xsum(k,i,N,v[k]*v[k-i],sum,0.0); 00114 00115 if (r0) 00116 return sum/r0; 00117 else 00118 return sum; 00119 } 00120 00121 /**********************************************************/ 00122 /* mete en {vac} las autocorrelaciones desde {a} hasta {b}, 00123 del vector {v} de {N} elementos. 00124 Por tanto {vac} debe tener sitio para ({b}-{a}+1) elementos (funcion 00125 nel_acorr_ab() ) de tipo SPL_FLOAT. 00126 {devuelve} el vector de autocorrelaciones {vac}. 00127 {a} y {b} deben ser positivos >= 0, con {a}<={b}. {N}>=0 */ 00128 00129 PUBLIC SPL_pFLOAT XAPI acorr_ab( SPL_pFLOAT v, SPL_INT N, SPL_pFLOAT vac, 00130 SPL_INT a, SPL_INT b ) 00131 { 00132 SPL_INT i,k; 00133 SPL_FLOAT sum; 00134 assert(N>=0); 00135 assert(a>=0); 00136 assert(b>=0); 00137 assert(b>=a); 00138 00139 for (i=a; i<=b; i++) { 00140 __xsum(k,i,N,v[k]*v[k-i],sum,0.0); 00141 vac[i-a] = sum; 00142 } 00143 return vac; 00144 } 00145 00146 /**********************************************************/ 00147 /* mete en {vac} las autocorrelaciones desde {a} hasta {b} 00148 del vector {v} de {N} elementos normalizadas a la autocorrelacion 00149 en el origen. 00150 Por tanto {vac} debe tener sitio para ({b}-{a}+1) elementos (funcion 00151 nel_acorr_ab() ) de tipo SPL_FLOAT. 00152 La funcion {devuelve} el valor de la autocorrelacion en el origen. 00153 {a} y {b} deben ser positivos >= 0, con {a}<={b}. {N}>=0. 00154 Si R(0) es nula, la normalizacion no se efectua y la funcion 00155 {devuelve} 0.0 */ 00156 00157 PUBLIC SPL_FLOAT XAPI acorr_ab_n( SPL_pFLOAT v, SPL_INT N, SPL_pFLOAT vac, 00158 SPL_INT a, SPL_INT b ) 00159 { 00160 SPL_INT i,k; 00161 SPL_FLOAT sum, r0; 00162 assert(N>=0); 00163 assert(a>=0); 00164 assert(b>=0); 00165 assert(b>=a); 00166 00167 __xsum(k,0,N,v[k]*v[k],r0,0.0); 00168 00169 if (!r0) { 00170 for (i=a; i<=b; i++) { 00171 __xsum(k,i,N,v[k]*v[k-i],sum,0.0); 00172 vac[i-a] = sum; 00173 } 00174 } 00175 else { 00176 for (i=a; i<=b; i++) { 00177 __xsum(k,i,N,v[k]*v[k-i],sum,0.0); 00178 vac[i-a] = sum/r0; 00179 } 00180 } 00181 00182 return r0; 00183 } 00184 00185 /**********************************************************/ 00186 /* {devuelve} el numero de elementos SPL_FLOAT que debe tener un 00187 vector de autocorrelaciones para poder almacenar las 00188 autocorrelaciones entre R(a) y R(b), ambas incluidas. 00189 {a} y {b} deben ser positivos >= 0, con {a}<={b} */ 00190 00191 PUBLIC SPL_INT XAPI nel_acorr_ab( SPL_INT a, SPL_INT b ) 00192 { 00193 assert(a>=0); 00194 assert(b>=0); 00195 assert(b>=a); 00196 00197 return b-a+1; 00198 } 00199 00200 /**********************************************************/ 00201 /* Funciones de covarianza (covar_???) y covarianza 00202 normalizada a la del origen (covar_???_n). 00203 00204 Reciben como parametros basicos: 00205 00206 - SPL_pFLOAT {v} : vector de longitud {N} del que se quieren calcular 00207 . covarianzas. 00208 - SPL_INT {N} : Longitud del vector {v}. {N}>=0 00209 - SPL_INT {p} : Longitud de la 'cola' dentro de las {N} muestras pasadas. 00210 . La ventana de analisis esta realmente formada por las 00211 . ultimas {N}-{p} muestras del vector. 00212 . {p}>=0 00213 00214 Ademas reciben otros parametros: 00215 00216 * Las funciones covar_ij_? reciben: 00217 . - SPL_INT {i}, SPL_INT {j} : para calcular la covarianza en (i,j) 00218 . {i}>=0, {j}>=0 00219 . La funcion {devuelve} covarianza(i,j) 00220 00221 * Las funciones xcovm_??_? crean 'pseudo matrices' de covarianzas, 00222 . que representan el sistema de ecuaciones completo que hay 00223 . que resolver (por cholesky) para obtener los LPC. 00224 00225 Hay un juego de funciones similar a las covar y xcovm pero denominadas 00226 covar_w y xcovm_w. Calculan covarianzas modificadas por un enventanado, 00227 tipicamente hamming, con objeto de obtener analisis predictivos 00228 mejores (Atal : los coeficientes no bailan tanto ... ), pero produce 00229 anchos de banda algo mas estrechos. Estas funciones reciben la ventana 00230 en el vector {vw}, de {N}-{p} puntos. 00231 00232 Ref: 00233 . Digital Processing of Speech Signals 00234 . L.R. Rabiner / R.W Schafer 00235 . Prentice Hall 00236 00237 Ref. covarianzas modificadas: 00238 . S. Singhal and B. S. Atal 00239 . Improving performance of multi-pulse LPC coders at low bit rates. 00240 . Proc. Int. Conf. ASSP vol 1, Paper 1.3 00241 */ 00242 /**********************************************************/ 00243 /* {devuelve} la covarianza ({i},{j}) del vector {v} de {N} elementos. 00244 De este vector, la 'trama de analisis' (frame) esta formada 00245 solo por los ultimos ({N}-{p}) elementos. 00246 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00247 covarianza {i},{j} en la que {i} o/y {j} puedan llegar a valer {p}, por 00248 ejemplo en una matriz de covarianzas de orden {p}. 00249 {i},{j} deben ser positivos <= {p}. {N}>=0. {p}<{N} */ 00250 00251 PUBLIC SPL_FLOAT XAPI covar_ij( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00252 SPL_INT i, SPL_INT j ) 00253 { 00254 SPL_INT k; 00255 SPL_FLOAT sum; 00256 assert(N>=0); 00257 assert(i>=0); 00258 assert(j>=0); 00259 assert(i<=p); 00260 assert(j<=p); 00261 assert(p<N); 00262 00263 __xsum(k,p,N,v[k-i]*v[k-j],sum,0.0); 00264 00265 return sum; 00266 } 00267 00268 /**********************************************************/ 00269 /* {devuelve} la covarianza ({i},{j}) del vector {v} de {N} elementos, 00270 normalizada a la covarianza en 0,0. 00271 De este vector, la 'trama de analisis' (frame) esta formada 00272 solo por los ultimos ({N}-{p}) elementos. 00273 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00274 covarianza {i},{j} en la que {i} o/y {j} puedan llegar a valer {p}, por 00275 ejemplo en una matriz de covarianzas de orden {p}. 00276 {i},{j} deben ser positivos <= {p}. {N}>=0. {p}<{N} 00277 Si la covarianza en (0,0) es nula, la normalizacion no se efectua */ 00278 00279 PUBLIC SPL_FLOAT XAPI covar_ij_n( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00280 SPL_INT i, SPL_INT j ) 00281 { 00282 SPL_INT k; 00283 SPL_FLOAT sum, c00; 00284 assert(N>=0); 00285 assert(i>=0); 00286 assert(j>=0); 00287 assert(i<=p); 00288 assert(j<=p); 00289 assert(p<N); 00290 00291 __xsum(k,p,N,v[k]*v[k],c00,0.0); 00292 __xsum(k,p,N,v[k-i]*v[k-j],sum,0.0); 00293 00294 if (c00) 00295 return sum/c00; 00296 else 00297 return sum; 00298 } 00299 00300 /**********************************************************/ 00301 /* {devuelve} el indice dentro de un array para el elemento {i},{j} de 00302 una matriz de covarianzas de orden {p}. 00303 {i} son filas, {j} columnas. 00304 Aunque el elemento ({i},{j}) es igual que el ({j},{i}), 00305 enviar SIEMPRE {j}<={i}. 00306 {i}>=1, {j}>=1. 00307 El funcionamiento es erroneo si se envia {i}>{p} o {j}>{p}. Esta situacion 00308 no se detecta nunca (assert) por esta funcion, ya que no necesita 00309 recibir el valor de {p}. 00310 00311 La estructura que se almacena en esta matriz es la siguiente: 00312 00313 . C(1,1) 00314 . C(2,1) C(2,2) 00315 . .... 00316 . C(p,1) ............C(p,p) 00317 00318 La matriz de covarianzas por ser simetrica se almacena como matriz 00319 triangular (la primera fila tiene un elemento, la segunda 2... 00320 hasta p lineas). 00321 00322 Se almacena todo por lineas de izq. a derecha y de arriba a abajo: 00323 . C(1,1) C(2,1) C(2,2) C(3,1) ... C(p,p) 00324 p es el orden de la matriz de covarianzas. 00325 00326 El elemento ({i},{j}) representa a la covarianza C({i},{j}) en prediccion 00327 de corto termino, en la que el indice encaja con el retardo aplicado 00328 a la trama de analisis. En prediccion de largo termino o de algun otro 00329 tipo general, ({i},{j}) representara la covarianza C(M(i),M(j)) siendo 00330 M(i) y M(j) dos retardos cualesquiera. En cualquier caso, para {i}=0 o 00331 {j}=0, M(0) es obligatoriamente un retardo nulo: M(0)=0. */ 00332 00333 /* Esta macro esta en spl.h 00334 #define idx_covm(i,j) idx_matrix_sim(i,j) 00335 */ 00336 00337 /**********************************************************/ 00338 /* {devuelve} el numero de elementos (SPL_FLOAT) que se deben 00339 almacenar en una matriz de covarianzas de orden {p}. {p}>=0 */ 00340 00341 /* esta macro esta en spl.h 00342 #define nel_covm(p) nel_matrix_sim(p) 00343 */ 00344 00345 /**********************************************************/ 00346 /* {devuelve} el indice dentro de un array para el elemento {i},{j} de 00347 una "pseudo-matriz" de covarianzas de orden {p}, que es un sistema 00348 de ecuaciones de covarianzas (prediccion lineal de orden {p}). 00349 {i} son filas, {j} columnas. 00350 Aunque el elemento ({i},{j}) es igual que el ({j},{i}), 00351 enviar SIEMPRE {j}<={i}. 00352 {i}>=0, {j}>=0. {i}<={p}, {j}<={p}. 00353 La estructura que se almacena en esta pseudo-matriz es la siguiente: 00354 00355 . C(0,0) <------- (factor de potencia) 00356 . C(1,0) C(2,0) .... C(p,0) <----- (termino independiente) 00357 . C(1,1) <------- (matriz de... 00358 . C(2,1) C(2,2) <-----| 00359 . .... <-----| 00360 . C(p,1) ............C(p,p) <------- ...covarianzas) 00361 00362 El factor de potencia es un elemento. El termino independiente es un 00363 vector de {p} elementos. La matriz de covarianzas por ser simetrica 00364 se almacena como matriz triangular (la primera fila tiene un elemento, 00365 la segunda 2... hasta {p} lineas). 00366 00367 Se almacena todo por lineas de izq. a derecha y de arriba a abajo: 00368 . C(0,0) C(1,0) C(2,0) ... C(p,0) C(1,1) C(2,1) C(2,2) C(3,1) ... C(p,p) 00369 {p} es el orden de la matriz de covarianzas 00370 00371 El elemento ({i},{j}) representa a la covarianza C(i,j) en prediccion 00372 de corto termino, en la que el indice encaja con el retardo aplicado 00373 a la trama de analisis. En prediccion de largo termino o de algun otro 00374 tipo general, ({i},{j}) representara la covarianza C(M(i),M(j)) siendo 00375 M(i) y M(j) dos retardos cualesquiera. En cualquier caso, para {i}=0 o 00376 {j}=0, M(0) es obligatoriamente un retardo nulo: M(0)=0. */ 00377 00378 PUBLIC SPL_INT XAPI idx_xcovm( SPL_INT i, SPL_INT j, SPL_INT p ) 00379 { 00380 assert(i>=0); 00381 assert(j>=0); 00382 assert(j<=i); 00383 assert(i<=p); 00384 00385 return __idx_xcovm(i,j,p); 00386 } 00387 00388 /**********************************************************/ 00389 /* {devuelve} el numero de elementos que se deben almacenar en una 00390 pseudo-matriz de covarianzas de orden {p} ({p}>=0) */ 00391 00392 PUBLIC SPL_INT XAPI nel_xcovm( SPL_INT p ) 00393 { 00394 assert(p>=0); 00395 00396 return __idx_xcovm(p+1,1,p); 00397 } 00398 00399 /**********************************************************/ 00400 /* mete en {mcv} la "pseudo-matriz" de covarianzas de orden {p} para 00401 analisis predictivo de corto termino del vector {v}. 00402 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00403 El vector {v} es de {N} elementos. 00404 De este vector, la 'trama de analisis' (frame) esta formada 00405 solo por los ultimos ({N}-{p}) elementos. 00406 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00407 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {p} en la matriz 00408 de covarianzas de orden {p}. 00409 {N}>=0. {p}>=0. {p}<{N} 00410 {devuelve} un puntero a {mcv} */ 00411 00412 PUBLIC SPL_pFLOAT XAPI xcovm_st( SPL_pFLOAT v, SPL_INT N, 00413 SPL_INT p, SPL_pFLOAT mcv ) 00414 { 00415 SPL_INT i,j,k,l; 00416 SPL_FLOAT sum; 00417 assert(N>=0); 00418 assert(p>=0); 00419 assert(p<N); 00420 00421 for (i=0; i<=p; i++) { /* calcula C(i,0), i=0...p */ 00422 __xsum(k,p,N,v[k-i]*v[k],sum,0.0); 00423 mcv[i]=sum; 00424 } 00425 00426 j=p+1; /* calcula el resto a partir de los anteriores */ 00427 for (i=0; i<p; i++) { /* p filas */ 00428 j+=i; /* en el elemento j comienza la fila */ 00429 l=0; 00430 sum=mcv[i]; /* covarianza de partida */ 00431 /* calcula cov. de la diagonal de la fila i+1 */ 00432 for (k=1; k<=p-i; ) { 00433 mcv[j+l]=(sum+=v[p-k]*v[p-k-i]-v[N-k]*v[N-k-i]); 00434 k++; 00435 l+=(k+i); 00436 } 00437 } 00438 00439 return mcv; 00440 } 00441 00442 /**********************************************************/ 00443 /* mete en {mcv} la "pseudo-matriz" de covarianzas de orden {p} 00444 normalizadas a la covarianza en (0,0), para analisis predictivo 00445 de corto termino del vector {v}. 00446 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00447 El vector {v} es de {N} elementos. 00448 De este vector, la 'trama de analisis' (frame) esta formada 00449 solo por los ultimos ({N}-{p}) elementos. 00450 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00451 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {p} en la matriz 00452 de covarianzas de orden {p}. 00453 {N}>=0. {p}>=0. {p}<{N} 00454 La funcion {devuelve} el valor de la covarianza en (0,0). 00455 Si la covarianza en (0,0) es nula, la normalizacion no se efectua y 00456 la funcion {devuelve} 0.0 */ 00457 00458 PUBLIC SPL_FLOAT XAPI xcovm_st_n( SPL_pFLOAT v, SPL_INT N, 00459 SPL_INT p, SPL_pFLOAT mcv ) 00460 { 00461 SPL_INT i; 00462 SPL_FLOAT c00; 00463 00464 xcovm_st(v,N,p,mcv); 00465 if (mcv[0]) { 00466 c00=mcv[0]; 00467 for (i=nel_xcovm(p); i>0;) 00468 mcv[--i] /= c00; 00469 return c00; 00470 } 00471 00472 return 0.0; 00473 } 00474 00475 /**********************************************************/ 00476 /* mete en {mcv} la "pseudo-matriz" de covarianzas de orden {p} para 00477 analisis predictivo de largo termino del vector {v}. El retardo 00478 del predictor es {M}, y se utilizan las covarianzas con indices 00479 en {M}, {M}+1 ... {M}+{p}-1. 00480 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00481 El vector {v} es de {N} elementos. 00482 De este vector, la 'trama de analisis' (frame) esta formada 00483 solo por los ultimos {fN} elementos. 00484 Los {N}-{fN} primeros elementos son la 'cola' necesaria para calcular la 00485 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {M}+{p}-1 en la 00486 matriz de covarianzas de orden {p}. Por tanto, la cola {N}-{fN} debera 00487 tener por lo menos {M}+{p}-1 elementos. 00488 {N}>=0. {p}>=0. {M}>=0 00489 {devuelve} un puntero a {mcv} */ 00490 00491 PUBLIC SPL_pFLOAT XAPI xcovm_lt( SPL_pFLOAT v, SPL_INT N, SPL_INT fN, 00492 SPL_INT p, SPL_INT M, SPL_pFLOAT mcv ) 00493 { 00494 SPL_INT i,j,k,l; 00495 SPL_FLOAT sum; 00496 SPL_INT xp=N-fN; 00497 assert(fN>=0); 00498 assert(fN<N); 00499 assert(p>=0); 00500 assert(xp>=M+p-1); 00501 assert(M>=0); 00502 00503 if (p) { 00504 __xsum(k,xp,N,v[k]*v[k],sum,0.0); /* calcula C(0,0)*/ 00505 mcv[0]=sum; 00506 } 00507 00508 for (i=0; i<p; ) { /* calcula C(M+i-1,0), i=1...p */ 00509 __xsum(k,xp,N,v[k-i-M]*v[k],sum,0.0); 00510 i++; 00511 mcv[i]=sum; 00512 } 00513 00514 j=p+1; /* calcula el resto */ 00515 for (i=0; i<p; i++) { /* p filas */ 00516 j+=i; /* en el elemento j comienza la fila */ 00517 __xsum(k,xp,N,v[k-i-M]*v[k-M],sum,0.0); /* calcula el primero */ 00518 mcv[j]=sum; 00519 l=(i+2); 00520 /* calcula los de la diagonal a partir del primero */ 00521 for (k=1; k<p-i; ) { 00522 mcv[j+l]=(sum+=v[xp-M-k]*v[xp-M-k-i]-v[N-M-k]*v[N-M-k-i]); 00523 k++; 00524 l+=(k+1+i); 00525 } 00526 } 00527 00528 return mcv; 00529 } 00530 00531 /**********************************************************/ 00532 /* mete en {mcv} la "pseudo-matriz" de covarianzas normalizadas 00533 a la del origen de orden {p} para analisis predictivo de largo 00534 termino del vector {v}. El retardo del predictor es {M}, y se 00535 utilizan las covarianzas con indices en {M}, {M}+1 ... {M}+{p}-1. 00536 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00537 El vector {v} es de {N} elementos. 00538 De este vector, la 'trama de analisis' (frame) esta formada 00539 solo por los ultimos {fN} elementos. 00540 Los {N}-{fN} primeros elementos son la 'cola' necesaria para calcular la 00541 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {M}+{p}-1 en la 00542 matriz de covarianzas de orden {p}. Por tanto, la cola {N}-{fN} debera 00543 tener por lo menos {M}+{p}-1 elementos. 00544 {N}>=0. {p}>=0. {M}>=0 00545 La funcion {devuelve} el valor de la covarianza en (0,0). 00546 Si la covarianza en (0,0) es nula, la normalizacion no se efectua y 00547 la funcion {devuelve} 0.0 */ 00548 00549 PUBLIC SPL_FLOAT XAPI xcovm_lt_n( SPL_pFLOAT v, SPL_INT N, SPL_INT fN, 00550 SPL_INT p, SPL_INT M, SPL_pFLOAT mcv ) 00551 { 00552 SPL_INT i; 00553 SPL_FLOAT c00; 00554 00555 xcovm_lt(v,N,fN,p,M,mcv); 00556 if (mcv[0]) { 00557 c00=mcv[0]; 00558 for (i=nel_xcovm(p); i>0;) 00559 mcv[--i] /= c00; 00560 return c00; 00561 } 00562 00563 return 0.0; 00564 } 00565 00566 /**********************************************************/ 00567 /* {devuelve} la covarianza ponderada ({i},{j}) del vector {v} de 00568 {N} elementos. 00569 De este vector, la 'trama de analisis' (frame) esta formada 00570 solo por los ultimos ({N}-{p}) elementos. 00571 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00572 covarianza {i},{j} en la que {i} o/y {j} puedan llegar a valer {p}, por 00573 ejemplo en una matriz de covarianzas de orden {p}. 00574 La ventana de ponderacion se pasa en el vector {vw}, de {N}-{p} puntos. 00575 {i},{j} deben ser positivos <= {p}. {N}>=0. {p}<{N} */ 00576 00577 PUBLIC SPL_FLOAT XAPI covar_w_ij( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00578 SPL_INT i, SPL_INT j, SPL_pFLOAT vw ) 00579 { 00580 SPL_INT k; 00581 SPL_FLOAT sum; 00582 assert(N>=0); 00583 assert(i>=0); 00584 assert(j>=0); 00585 assert(i<=p); 00586 assert(j<=p); 00587 assert(p<N); 00588 00589 __xsum(k,p,N,v[k-i]*v[k-j]*vw[k-p],sum,0.0); 00590 00591 return sum; 00592 } 00593 00594 /**********************************************************/ 00595 /* {devuelve} la covarianza ponderada({i},{j}) del vector {v} de {N} 00596 elementos, normalizada a la covarianza (ponderada) en 0,0. 00597 De este vector, la 'trama de analisis' (frame) esta formada 00598 solo por los ultimos ({N}-{p}) elementos. 00599 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00600 covarianza {i},{j} en la que {i} o/y {j} puedan llegar a valer {p}, por 00601 ejemplo en una matriz de covarianzas de orden {p}. 00602 La ventana de ponderacion se pasa en el vector {vw}, de {N}-{p} puntos. 00603 {i},{j} deben ser positivos <= {p}. {N}>=0. {p}<{N} 00604 Si la covarianza en (0,0) es nula, la normalizacion no se efectua */ 00605 00606 PUBLIC SPL_FLOAT XAPI covar_w_ij_n( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00607 SPL_INT i, SPL_INT j, SPL_pFLOAT vw ) 00608 { 00609 SPL_INT k; 00610 SPL_FLOAT sum, c00; 00611 assert(N>=0); 00612 assert(i>=0); 00613 assert(j>=0); 00614 assert(i<=p); 00615 assert(j<=p); 00616 assert(p<N); 00617 00618 __xsum(k,p,N,v[k]*v[k]*vw[k-p],c00,0.0); 00619 __xsum(k,p,N,v[k-i]*v[k-j],sum,0.0); 00620 00621 if (c00) 00622 return sum/c00; 00623 else 00624 return sum; 00625 } 00626 00627 /**********************************************************/ 00628 /* mete en {mcv} la "pseudo-matriz" de covarianzas ponderadas 00629 de orden {p} para analisis predictivo de corto termino del vector {v}. 00630 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00631 El vector {v} es de {N} elementos. 00632 De este vector, la 'trama de analisis' (frame) esta formada 00633 solo por los ultimos ({N}-{p}) elementos. 00634 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00635 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {p} en la matriz 00636 de covarianzas de orden {p}. 00637 La ventana de ponderacion se pasa en el vector {vw}, de {N}-{p} puntos. 00638 {N}>=0. {p}>=0. {p}<{N} 00639 {devuelve} un puntero a {mcv} */ 00640 00641 PUBLIC SPL_pFLOAT XAPI xcovm_w_st( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00642 SPL_pFLOAT mcv, SPL_pFLOAT vw ) 00643 { 00644 SPL_INT i,j,k,l; 00645 SPL_FLOAT sum; 00646 assert(N>=0); 00647 assert(p>=0); 00648 assert(p<N); 00649 00650 for (i=0; i<=p; i++) { /* calcula C(i,0), i=0...p */ 00651 __xsum(k,p,N,v[k-i]*v[k]*vw[k-p],sum,0.0); 00652 mcv[i]=sum; 00653 } 00654 00655 l=p+1; 00656 for (i=1; i<=p; i++) { 00657 for (j=1; j<=i; j++) { 00658 __xsum(k,p,N,v[k-i]*v[k-j]*vw[k-p],sum,0.0); 00659 mcv[l++]=sum; 00660 } 00661 } 00662 00663 return mcv; 00664 } 00665 00666 /**********************************************************/ 00667 /* mete en {mcv} la "pseudo-matriz" de covarianzas ponderadas 00668 de orden {p} normalizadas a la covarianza (ponderada) en (0,0), 00669 para analisis predictivo de corto termino del vector {v}. 00670 Esta matriz debe tener sitio para nel_xcovm(p) elementos SPL_FLOAT. 00671 El vector {v} es de {N} elementos. 00672 De este vector, la 'trama de analisis' (frame) esta formada 00673 solo por los ultimos ({N}-{p}) elementos. 00674 Los {p} primeros elementos son la 'cola' necesaria para calcular la 00675 covarianza {i},{j} en la que {i} o/y {j} llegan a valer {p} en la matriz 00676 de covarianzas de orden {p}. 00677 La ventana de ponderacion se pasa en el vector {vw}, de {N}-{p} puntos. 00678 {N}>=0. {p}>=0. {p}<{N} 00679 La funcion {devuelve} el valor de la covarianza modificada en (0,0). 00680 Si la covarianza en (0,0) es nula, la normalizacion no se efectua y 00681 la funcion {devuelve} 0.0 */ 00682 00683 PUBLIC SPL_FLOAT XAPI xcovm_w_st_n( SPL_pFLOAT v, SPL_INT N, SPL_INT p, 00684 SPL_pFLOAT mcv, SPL_pFLOAT vw ) 00685 { 00686 SPL_INT i; 00687 SPL_FLOAT c00; 00688 00689 xcovm_w_st(v,N,p,mcv,vw); 00690 if (mcv[0]) { 00691 c00=mcv[0]; 00692 for (i=nel_xcovm(p); i>0;) 00693 mcv[--i] /= c00; 00694 00695 return c00; 00696 } 00697 00698 return 0.0; 00699 } 00700 00701 /**********************************************************/ 00702
1.5.6