Apply a digital filter (direct form II transposed): Difference between revisions

{{trans|Nim}}

 

V result = [0.0] * signal.len

L(i) 0 .< signal.len

L(r) result

print(‘#2.8’.format(r), end' ‘’)

 

{{out}}

 

=={{header|Ada}}==

 

procedure Apply_Filter is

Ada.Text_IO.New_Line;

end loop;

 

=={{header|ALGOL 68}}==

{{Trans|C++}} ... via Yabasic<br>

The default lower bound in Algol 68 arrays is 1, so the loops/subscripts have been adjusted accordingly.

PROC filter = ( []REAL a, b, signal, REF[]REAL result )VOID:

BEGIN

IF i MOD 5 /= 0 THEN print( ( ", " ) ) ELSE print( ( newline ) ) FI

OD

{{out}}

<pre>

=={{header|AppleScript}}==

{{trans|Julia}} — except that j starts from 2 in the second inner repeat, there being no point in fetching and performing math with the zero about to be overwritten. This change in turn allows the result list to be populated on the fly instead of being pre-populated with zeros.

if (b < a) then return b

return a

0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293, ¬

0.025930339848, 0.490105989562, 0.549391221511, 0.9047198589}

 

{{output}}

 

=={{header|C}}==

Given the number of values a coefficient or signal vector can have and the number of digits, this implementation reads data from a file and prints it to the console if no output file is specified or writes to the specified output file. Usage printed on incorrect invocation.

#include<stdlib.h>

#include<string.h>

return 0;

}

Input file, 3 lines containing first ( a ) and second ( b ) coefficient followed by the signal, all values should be separated by a single space:

<pre>

=={{header|C sharp|C#}}==

{{trans|Java}}

 

namespace ApplyDigitalFilter {

}

}

{{out}}

<pre>-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469

This uses the C++11 method of initializing vectors. In g++, use the -std=c++0x compiler switch.

 

#include <iostream>

using namespace std;

 

return 0;

 

{{out}}

=={{header|Common Lisp}}==

{{trans|zkl}}

(defparameter b #(0.16666667L0 0.50000000L0 0.50000000L0 0.16666667L0))

(defparameter s #(-0.917843918645 0.141984778794 1.20536903482 0.190286794412 -0.662370894973

when (>= i j) sum (* (svref a j) (svref out (- i j)))))

(svref a 0)))

{{out}}

<pre> -0.15297399

=={{header|D}}==

{{trans|Kotlin}}

 

alias T = real;

}

}

 

{{out}}

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

Dim As Integer j, k

Dim As Double tmp

Data 0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("%9.6f\n", v)

}

{{out}}

<pre>

=={{header|Groovy}}==

{{trans|Java}}

private static double[] filter(double[] a, double[] b, double[] signal) {

double[] result = new double[signal.length]

}

}

{{out}}

<pre>-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469

=={{header|Haskell}}==

The solution is based not on the explicit loops, as in strict imperative languages, but on lazy recursive trick known as "tying a knot".

 

-- lazy convolution of a list by given kernel

dFilter (a0:a) b s = tail res

where

 

=== Examples ===

There's probably a nicer way to do this:

 

t=. (#n) +/ .*&(|.n)\(}.n*0),y

A=.|.}.m

_0.435482 _1.08924 _0.537677 0.51705 1.05225

0.961854 0.69569 0.424356 0.196262 _0.0278351

 

=={{header|Java}}==

{{trans|Kotlin}}

private static double[] filter(double[] a, double[] b, double[] signal) {

double[] result = new double[signal.length];

}

}

{{out}}

<pre>-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469

=={{header|Julia}}==

{{trans|zkl}}

rst = zeros(sig)

for i in eachindex(sig)

0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293,

0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589]

{{output}}<pre>DF2TFilter(acoef, bcoef, signal) = [-0.152974, -0.435258, -0.136043, 0.697503, 0.656445, -0.435482, -1.08924, -0.537677, 0.51705, 1.05225, 0.961854, 0.69569, 0.424356, 0.196262, -0.0278351, -0.211722, -0.174746, 0.0692584, 0.385446, 0.651771]</pre>

 

=={{header|Kotlin}}==

{{trans|C++}}

 

fun filter(a: DoubleArray, b: DoubleArray, signal: DoubleArray): DoubleArray {

print(if ((i + 1) % 5 != 0) ", " else "\n")

}

 

{{out}}

=={{header|Lua}}==

{{trans|C++}}

local out = {}

for i=1,table.getn(input) do

end

 

{{out}}

<pre>-0.15297398950031, -0.43525782905022, -0.13604339698849, 0.69750332654796, 0.65644469246903, -0.43548245325611, -1.0892394611529, -0.53767654956275, 0.51704999231321, 1.0522497471554, 0.96185430037364, 0.6956900940096, 0.42435629509553, 0.19626223182179, -0.027835124463393, -0.21172191545012, -0.17474556222276, 0.069258408901195, 0.38544587430744, 0.65177083881931,</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

a = {1.00000000, -2.77555756*^-16, 3.33333333*^-01, -1.85037171*^-17};

signal = {-0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412, -0.662370894973, -1.00700480494, -0.404707073677, 0.800482325044, 0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195, 0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293, 0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589};

{{out}}

<pre>{-0.152974,-0.435258,-0.136043,0.697503,0.656445,-0.435482,-1.08924,-0.537677,0.51705,1.05225,0.961854,0.69569,0.424356,0.196262,-0.0278351,-0.211722,-0.174746,0.0692584,0.385446,0.651771}</pre>

=={{header|MATLAB}}==

MATLAB is commonly used for filter design and implementation. To implement this filter, and display the original signal and the filtered result:

signal = [-0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412, -0.662370894973, -1.00700480494, -0.404707073677 ,0.800482325044, 0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195, 0.400833448236, -0.2085993586, -0.172842103641, -0.134316096293, 0.0259303398477, 0.490105989562, 0.549391221511, 0.9047198589];

a = [1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17];

xlabel('n')

title('Filtered Signal')

 

{{out}}

=={{header|Nim}}==

{{trans|Kotlin}}

import strformat

 

for i in 0..result.high:

stdout.write fmt"{result[i]: .8f}"

 

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

a := [1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17];

return result;

}

 

{{output}}

 

=={{header|ooRexx}}==

a=.array~of(1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17)

b=.array~of(0.16666667, 0.5, 0.5, 0.16666667)

 

::OPTIONS digits 24 /* Numeric Digits 24, everywhere */

{{out|output}}

<pre> 1 -0.152973989500

=={{header|Perl}}==

{{trans|Raku}}

use List::AllUtils 'natatime';

 

printf(' %10.6f' x 5 . "\n", @values);

}

{{out}}

<pre> -0.152974 -0.435258 -0.136043 0.697503 0.656445

Note however that the a[j]* starts from index 2, unlike Julia/C/Raku/Rust/Sidef/zkl,

but the same as C++/C#/D/Java/Kotlin - and it does not seem to make any difference...

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">direct_form_II_transposed_filter</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">signal</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">direct_form_II_transposed_filter</span><span style="color: #0000FF;">(</span><span style="color: #000000;">acoef</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">bcoef</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">signal</span><span style="color: #0000FF;">),{</span><span style="color: #004600;">pp_FltFmt</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%9.6f"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">pp_Maxlen</span><span style="color: #0000FF;">,</span><span style="color: #000000;">110</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

{{trans|Phix}}

 

( 1.00000000 -2.77555756e-16 3.33333333e-01 -1.85037171e-17 ) var a

ps> a 1 get nip / ps> swap i set >ps

endfor

{{out}}

<pre>[-0.152973989500313, -0.435257829050217, -0.13604339698849, 0.697503326547963, 0.656444692469029, -0.435482453256106, -1.089239461152929, -0.537676549562755, 0.517049992313214, 1.052249747155353, 0.961854300373645, 0.695690094009605, 0.424356295095532, 0.196262231821789, -0.0278351244633933, -0.211721915450118, -0.174745562222761, 0.0692584089011949, 0.385445874307439, 0.651770838819305]

=={{header|Python}}==

 

from __future__ import print_function

from scipy import signal

plt.plot(sig, 'b')

plt.plot(filt, 'r--')

 

{{out}}

{{trans|C}} Strangely, C was more informative than Common Lisp in helping figure out what was going on here.

 

 

(define a (vector 1.00000000E0 -2.77555756E-16 3.33333333E-01 -1.85037171E-17))

filtered-signal)

 

 

{{out}}

{{trans|zkl}}

 

my @out = 0 xx @signal;

for ^@signal -> $i {

 

say TDF-II-filter(@signal, @a, @b)».fmt("% 0.8f")

{{out}}

<pre>(-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469,

===version 1===

{{trans|Julia}}

@a= '1 -2.77555756e-16 3.33333333e-1 -1.85037171e-17' /*filter coefficients*/

@b= 0.16666667 0.5 0.5 0.16666667 /* " " */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output}}

<pre>

===version 2===

{{trans|Julia}}

Numeric Digits 24

acoef = '1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17'

ret.i=temp/a.1

Say format(i,2) format(ret.i,2,12)

{{out|output}}

<pre> 1 -0.152973989500

=={{header|Ruby}}==

{{trans|C#}}

result = Array.new(signal.length(), 0.0)

for i in 0..signal.length()-1 do

end

 

{{out}}

<pre>-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469

=={{header|Rust}}==

{{trans|Java}}

 

struct IIRFilter<'f>(&'f [f32], &'f [f32]);

}

println!();

{{out|output}}

<pre>

{{libheader|Scastie qualified}}

{{works with|Scala|2.13}}

private def filter(a: Vector[Double],

b: Vector[Double],

.foreach(line => println(line.mkString(" ")))

 

 

=={{header|Sidef}}==

{{trans|Raku}}

var out = [0]*signal.len

for i in ^signal {

say "["

say f.map { "% 0.8f" % _ }.slices(5).map{.join(', ')}.join(",\n")

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function Filter(a As Double(), b As Double(), signal As Double()) As Double()

End Sub

 

{{out}}

<pre>-0.15297399, -0.43525783, -0.13604340, 0.69750333, 0.65644469

=={{header|Vlang}}==

{{trans|Go}}

b []f64

a []f64

println("${v:9.6}")

}

 

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var filter = Fn.new { |a, b, signal|

Fmt.write("$11.8f", result[i])

System.write(((i + 1) % 5 != 0) ? ", " : "\n")

 

{{out}}

=={{header|Yabasic}}==

{{trans|D}}

local i, j, tmp

print

end if

 

=={{header|zkl}}==

{{trans|C++}}

out:=List.createLong(signal.len(),0.0); // vector of zeros

foreach i in (signal.len()){

}

out

-0.662370894973,-1.00700480494, -0.404707073677, 0.800482325044,

0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195,

b:=T(0.16666667, 0.5, 0.5, 0.16666667 );

result:=direct_form_II_transposed_filter(b,a,signal);

{{out}}

<pre>