### Re: [Scilab-users] Unexpected result using horner

```
Le 25/07/2022 à 02:44, Federico Miyara a écrit :

Samuel,

1) what shows you that iir() is correct while the analpf + horner way
is not?

There are several reasons:

a) The result of using iir() is consistent with the expected frequency
response, since it is equal to the analog filter response except at
high frequency, an expected artifact for IIR filters. The other
solution is completely different.

b) The degree of the denominator should be 6 but when using horner it
reduces to 3.

My own informal and not very deep analysis suggests that as all the
poles are very close to unity, may be horner() performs some
simplification and simplifies things incorrectly, which might
dramatically change the frequency response.

2) With the analpf + horner method, assuming that it is not correct,
what shows you that horner is not correct, while analpf is correct,
instead of the opposite or both incorrect?

analpf() is a very simple algorithm, at least for Butterworth, since
explicit formulas for the poles exist and in all the cases I have
tested the result is the expected one, particularly in this case.

3) do you have a reference about the equivalence?

The substitution of the bilinear transformation is the usual method to
get an IIR digital filter from an analog prototype. They aren't
completely equivalent, but very similar up to about half Nyquist
frequency. Any book on digital signal processing includes that
transformation. Also https://en.wikipedia.org/wiki/Bilinear_transform

4) have you tried after simp_mode(%f)?

No, but this might be the answer considering my reply to 2). I'll try
it later.

To get equivalent transfer functions, you need
a) indeed to turn simp_mode(%f),
b) to run
hBPz1= iir(3, "bp", "butt", fo/Fs*[2^(-1/6), 2^(1/6)], [0 0])
hBPz1= iir(3, "bp", "butt", fo/Fs*[2^(1/6),2^(-1/6)], [0 0])

Then the curves of both transfer functions are superimposed.

clf,  plot(linspace(0.5,1.5,100),  [hBPsz,  hBPz1]) When working with polynomials or rationals, one must keep in
mind that every time that their roots or/and poles have close values,
then results become very sensitive to numerical round-off errors or
uncertainties. The roots of a polynomial of degree N can't be computed
from its coefficients with a numerical relative accuracy better than
%eps^(1/N). If this uncertainty becomes bigger than the distance between
roots values, then things become really bad.

Samuel

___
users mailing list
users@lists.scilab.org
http://lists.scilab.org/mailman/listinfo/users

```

### Re: [Scilab-users] Unexpected result using horner

```

Samuel,

1) what shows you that iir() is correct while the analpf + horner way
is not?

There are several reasons:

a) The result of using iir() is consistent with the expected frequency
response, since it is equal to the analog filter response except at high
frequency, an expected artifact for IIR filters. The other solution is
completely different.

b) The degree of the denominator should be 6 but when using horner it
reduces to 3.

My own informal and not very deep analysis suggests that as all the
poles are very close to unity, may be horner() performs some
simplification and simplifies things incorrectly, which might
dramatically change the frequency response.

2) With the analpf + horner method, assuming that it is not correct,
what shows you that horner is not correct, while analpf is correct,
instead of the opposite or both incorrect?

analpf() is a very simple algorithm, at least for Butterworth, since
explicit formulas for the poles exist and in all the cases I have tested
the result is the expected one, particularly in this case.

3) do you have a reference about the equivalence?

The substitution of the bilinear transformation is the usual method to
get an IIR digital filter from an analog prototype. They aren't
completely equivalent, but very similar up to about half Nyquist
frequency. Any book on digital signal processing includes that
transformation. Also https://en.wikipedia.org/wiki/Bilinear_transform

4) have you tried after simp_mode(%f)?

No, but this might be the answer considering my reply to 2). I'll try it
later.

Thanks.

Regerds,

Federico Miyara

Samuel

___
users mailing list
users@lists.scilab.org
http://lists.scilab.org/mailman/listinfo/users

--
El software de antivirus Avast ha analizado este correo electrónico en busca de
virus.
https://www.avast.com/antivirus
___
users mailing list
users@lists.scilab.org
http://lists.scilab.org/mailman/listinfo/users

```

### Re: [Scilab-users] Unexpected result using horner

```
Le 24/07/2022 à 13:34, Samuel Gougeon a écrit :

1) what shows you that iir() is correct while the analpf + horner way
is not?

2) With the analpf + horner method, assuming that it is not correct,
what shows you that horner is not correct, while analpf is correct,
instead of the opposite or both incorrect?

3) do you have a reference about the equivalence?

4) have you tried after simp_mode(%f)?

By the way, you may edit iir(). You will see that it uses analpf() as
well, plus bilt() and trans() instead of (directly) horner.

Then editing bilt and trans show a lot of code...

___
users mailing list
users@lists.scilab.org
http://lists.scilab.org/mailman/listinfo/users

```

### Re: [Scilab-users] Unexpected result using horner

```
Hello Federico,
Le 20/07/2022 à 22:47, Federico Miyara a écrit :

Dear All,

I have problems with this script:
Fs  =  44100;
fo  =  500;
B  =  2^(1/6)-2^(-1/6);
// Low-pass Butterworth
hLPs  =  analpf(3,"butt",[],1);
// Band-pass Butterworth centered at fo
hBPs  =  horner(hLPs,  (2*%pi*fo/%s  +  %s/(2*%pi*fo))/B)

// Apply bilinear transform
hBPz  =  horner(hBPs,  2*Fs*(%z  -  1)/(%z  +  1))
// Attempt to get the same using iir
hBPz1  =  iir(3,  "bp",  "butt",  fo/Fs*[2^(1/6),2^(-1/6)],  [0  0])
I attempt to design a discrete Butterworth band-pass filter using two
equivalent methods:

1) Manually applying a bilinear transform to the analog filter
designed with analpf()

2) Applying the function iir()

For some resaon I couldn't figure out, the first method yields an
unexpected result:

--> hBPz
hBPz  =
0.005 +0.016z +0.016z² +0.005z³
---
-0.9671578 +2.9195957z -2.9518237z² +z³

--> hBPz1
hBPz1  =
0.006 -0.017z² +0.017z⁴ -0.006z⁶
-

1.0335428 -6.1515162z +15.271063z² -20.239437z³ +15.104038z⁴
-6.0176897z⁵ +z⁶

The official function iir() is correct. The manual procedure
unexpectedly reduces the order of the denominator.

Maybe someone can find out what's going on...

1) what shows you that iir() is correct while the analpf + horner way is
not?

2) With the analpf + horner method, assuming that it is not correct,
what shows you that horner is not correct, while analpf is correct,
instead of the opposite or both incorrect?

3) do you have a reference about the equivalence?

4) have you tried after simp_mode(%f)?

Samuel
___
users mailing list
users@lists.scilab.org
http://lists.scilab.org/mailman/listinfo/users

```