Filtre numérique, Math en Java,

Question

J'ai besoin de votre aide, et merci d'avoir lu ma question! J'écris actuellement un programme java qui utilisera un filtre transposé Direket Form 2. Je sais que le filtre de fonction de Matlab fonctionnera très bien, mais je dois utiliser Java. Est-ce que quelqu'un vous connait pour implémenter ce Direkt Form 2 Transposed, cette fonction mathématique:

y (n) = b (1) * x (n) + b (2) * x (n-1) +. .. + b (nb + 1) * x (n-nb) - a (2) * y (n-1) - ... - a (na + 1) * y (n-na)

dans n'importe quelle langue Programmm? Tout ce qu'il faut, espérons-le, est un point à la direction, donc je peux comprendre! Peut-être qu'il y a un C Lib qui implémente certaines des fonctions de matlab, juste n'importe quoi.

Je vous remercie pour votre temps

vôtre Elektro

Suivi:

J'ai essayé pendant quelques jours pour comprendre votre fonction, mais je ne pouvais pas.

C'est la fonction de Matlab: Filtre

http://www.mathworks.com/access/helpdesk/help/techdoc/index.html?/access/helpdesk/help/techdoc/ref/filter.html&http://www.google.de/search?hl=de&q=filter+matlab&btnG=Google-Suche&meta=&aq=f&oq=

Tout ce que je sais est que je l'utilise en Matlab la fonction comme ceci:

newArray = filtre (1, LPC_Faktor, OldArray)

Tout ce que j'ai à faire est d'implémenter la fonction de filtre.

Alors pourriez-vous aider encore?

Merci

Elektro

Answer 1

Quelle que soit la langue que vous utilisez, la structure transposée sous forme directe II est assez simple.

Par exemple, en C, il pourrait être quelque chose comme:

float myFilter(float u) 
{ 
    static float[nb] x = {0,0,0,...,0); // initialize x 
    static float[na] y = {0,0,0,...,0); // initialize y 
    static float b1 = ....; // put b(1) here 
    static float[nb] b = {...,...,...,...,...}; // put b(2) to b(nb+1) here 
    static float[na] a = {...,...,...,...,...}; // put a(2) to a(na+1) values here 

    // initialization 
    float sum = 0; 
    int i=0; 

    // compute the value 
    for(i=0;i<nb;i++) 
    sum += b[i]*x[i]; 
    for(i=0;i<na;i++) 
    sum -= a[i]*y[i]; 
    sum += b1*u; 

    // prepare the values for the next time 
    for(i=1;i<nb;i++) 
    x[i] = x[i-1]; 
    x[0] = u; 
    for(i=1;i<na;i++) 
    y[i] = y[i-1]; 
    y[0] = sum; 

    // return the value 
    return sum; 
} 

Je n'ai pas testé le code, mais il est quelque chose comme ça. La forme directe II transposée est la forme la plus simple pour implémenter un filtre FIR (numériquement, et spécialement en point fixe, ce n'est pas le meilleur, mais c'est la forme qui nécessite le moins d'opérations).

Bien sûr, il est possible d'avoir une meilleure implémentation (avec un tableau cyclable, par exemple). Si nécessaire, je peux le fournir aussi.

EDIT: J'ai répondu trop rapidement. L'algorithme que vous fournissez

y(n) = b(1)x(n) + b(2)x(n-1) + ... + b(nb+1)x(n-nb) - a(2)y(n-1) - ... - a(na+1)*y(n-na) 

est pas la forme directe II, mais la forme directe I. Il faut stocker na + nb valeurs (n est l'ordre de votre filtre), alors que la forme directe II ne nécessite que max (na, nb). L'algorithme utilisé pour la forme directe II est

e(n) = u(n) - a(1)*e(n-1) - a(2)*e(n-2) - ... - a(na)*e(n-na) 
y(n) = b(1)*e(n-1) + b(2)*e(n-2) + ... + b(nb)*e(n-nb) 

Dites-moi si vous avez besoin de cette forme ou non.

Answer 2

après une longue recherche j'ai trouvé la réponse,

vous thank a montré le chemin rigth:

filter(int ord, float *a, float *b, int np, float *x, float *y) 
{ 
    int i,j; 
    y[0]=b[0] * x[0]; 
    for (i=1;i<ord+1;i++) 
    { 
     y[i]=0.0; 
     for (j=0;j<i+1;j++) 
      y[i]=y[i]+b[j]*x[i-j]; 
     for (j=0;j<i;j++) 
      y[i]=y[i]-a[j+1]*y[i-j-1]; 
    } 
    /* end of initial part */ 
    for (i=ord+1;i<np+1;i++) 
    { 
     y[i]=0.0; 
     for (j=0;j<ord+1;j++) 
      y[i]=y[i]+b[j]*x[i-j]; 
     for (j=0;j<ord;j++) 
      y[i]=y[i]-a[j+1]*y[i-j-1]; 
    } 
} /* end of filter */