Digital Filter, Mathematik in Java,

Question

Ich brauche Ihre Hilfe und danke Ihnen für das Lesen meiner Frage! Ich schreibe gerade ein Java-Programm, das einen Direkte Form 2 Transponierten Filter verwenden wird. Ich weiß, dass der Funktionsfilter in Matlab das gut machen wird, aber ich muss Java verwenden. So jemand weiß, dass Sie diese Direkt Form 2 Transponierte implementieren, diese mathematische Funktion:

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)

in einer Programmierm Sprache? Alles was es braucht, ist hoffentlich ein Punkt in die richtige Richtung, damit ich es herausfinden kann! Vielleicht gibt es eine C-Lib, die einige Matlab-Funktionen implementiert, einfach alles.

danke Also für Ihre Zeit

Ihr Elektro

Follow up:

ich für ein paar Tage versucht, Ihre Funktion zu verstehen, aber ich konnte es nicht.

Dies ist die Funktion von Matlab: Filter

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=

Alles was ich weiß ist, dass ich in Matlab die Funktion wie folgt verwenden:

newArray = Filter (1, LPC_Faktor, OldArray)

Alles, was ich tun muss, ist die Filterfunktion zu implementieren.

Also könnten Sie wieder helfen?

Dank

Elektro

Answer 1

welche Sprache auch immer Sie verwenden, ist die direkte Form II umgesetzt Struktur ganz einfach.

Zum Beispiel in C, könnte es sein, so etwas wie:

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; 
} 

ich nicht den Code testen habe, aber es ist so ähnlich.

Die direkte Form II transponiert ist die einfachste Form zur Implementierung eines FIR-Filters (numerisch, und speziell in Festkomma, es ist nicht die beste, aber es ist die Form, die weniger Operationen erfordert).

Natürlich ist es möglich, eine bessere Implementierung (zum Beispiel mit zyklischen Array) zu haben. Bei Bedarf kann ich es auch bereitstellen.

EDIT: Ich antwortete zu schnell. Der Algorithmus bieten Ihnen

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) 

ist nicht die direkte Form II, aber die direkte Form I. erfordert es na speichern + nb Werte (n ist die Reihenfolge der Filter), während die Direktform II nur max erfordert (na, nb). Der Algorithmus für die Direktform II verwendete

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) 

Sag mir, wenn Sie dieses Formular benötigen oder nicht.

Answer 2

, nachdem ich lange Suche die Antwort gefunden,

danken Ihnen gezeigt, die rigth Weg:

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 */