Rosetta Code

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

Page Discussion

Apply a digital filter (direct form II transposed) (view source)

Revision as of 21:30, 29 August 2022

88 bytes added ,  1 year ago
m
Automated syntax highlighting fixup (second round - minor fixes)
m (syntax highlighting fixup automation)
m (Automated syntax highlighting fixup (second round - minor fixes))
Line 12:
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F apply_filter(a, b, signal)
V result = [0.0] * signal.len
L(i) 0 .< signal.len
Line 47:
 
=={{header|Ada}}==
<syntaxhighlight lang=Ada"ada">with Ada.Text_IO;
 
procedure Apply_Filter is
Line 111:
{{Trans|C++}} ... via Yabasic<br>
The default lower bound in Algol 68 arrays is 1, so the loops/subscripts have been adjusted accordingly.
<syntaxhighlight lang="algol68">BEGIN # apply a digital filter #
PROC filter = ( []REAL a, b, signal, REF[]REAL result )VOID:
BEGIN
Line 151:
=={{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.
<syntaxhighlight lang="applescript">on min(a, b)
if (b < a) then return b
return a
Line 188:
 
{{output}}
<syntaxhighlight lang="applescript">{-0.1529739895, -0.43525782905, -0.136043396988, 0.697503326548, 0.656444692469, -0.435482453256, -1.089239461153, -0.537676549563, 0.517049992313, 1.052249747155, 0.961854300374, 0.69569009401, 0.424356295096, 0.196262231822, -0.027835124463, -0.21172191545, -0.174745562223, 0.069258408901, 0.385445874308, 0.651770838819}</syntaxhighlight>
 
=={{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.
<syntaxhighlight lang=C"c">
#include<stdlib.h>
#include<string.h>
Line 325:
=={{header|C sharp|C#}}==
{{trans|Java}}
<syntaxhighlight lang="csharp">using System;
 
namespace ApplyDigitalFilter {
Line 377:
This uses the C++11 method of initializing vectors. In g++, use the -std=c++0x compiler switch.
 
<syntaxhighlight lang="cpp">#include <vector>
#include <iostream>
using namespace std;
Line 435:
=={{header|Common Lisp}}==
{{trans|zkl}}
<syntaxhighlight lang="lisp">(defparameter a #(1.00000000L0 -2.77555756L-16 3.33333333L-01 -1.85037171L-17))
(defparameter b #(0.16666667L0 0.50000000L0 0.50000000L0 0.16666667L0))
(defparameter s #(-0.917843918645 0.141984778794 1.20536903482 0.190286794412 -0.662370894973
Line 476:
=={{header|D}}==
{{trans|Kotlin}}
<syntaxhighlight lang=D"d">import std.stdio;
 
alias T = real;
Line 532:
=={{header|FreeBASIC}}==
{{trans|Yabasic}}
<syntaxhighlight lang="freebasic">Sub Filtro(a() As Double, b() As Double, senal() As Double, resultado() As Double)
Dim As Integer j, k
Dim As Double tmp
Line 589:
 
=={{header|Go}}==
<syntaxhighlight lang="go">package main
 
import "fmt"
Line 666:
=={{header|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">class DigitalFilter {
private static double[] filter(double[] a, double[] b, double[] signal) {
double[] result = new double[signal.length]
Line 711:
=={{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".
<syntaxhighlight lang=Haskell"haskell">import Data.List (tails)
 
-- lazy convolution of a list by given kernel
Line 753:
There's probably a nicer way to do this:
 
<syntaxhighlight lang=J"j">Butter=: {{
t=. (#n) +/ .*&(|.n)\(}.n*0),y
A=.|.}.m
Line 784:
=={{header|Java}}==
{{trans|Kotlin}}
<syntaxhighlight lang=Java"java">public class DigitalFilter {
private static double[] filter(double[] a, double[] b, double[] signal) {
double[] result = new double[signal.length];
Line 830:
=={{header|Julia}}==
{{trans|zkl}}
<syntaxhighlight lang="julia">function DF2TFilter(a::Vector, b::Vector, sig::Vector)
rst = zeros(sig)
for i in eachindex(sig)
Line 852:
=={{header|Kotlin}}==
{{trans|C++}}
<syntaxhighlight lang="scala">// version 1.1.3
 
fun filter(a: DoubleArray, b: DoubleArray, signal: DoubleArray): DoubleArray {
Line 901:
=={{header|Lua}}==
{{trans|C++}}
<syntaxhighlight lang="lua">function filter(b,a,input)
local out = {}
for i=1,table.getn(input) do
Line 956:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang=Mathematica"mathematica">b = {0.16666667, 0.5, 0.5, 0.16666667};
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};
Line 965:
=={{header|MATLAB}}==
MATLAB is commonly used for filter design and implementation. To implement this filter, and display the original signal and the filtered result:
<syntaxhighlight lang=MATLAB"matlab">
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];
Line 999:
=={{header|Nim}}==
{{trans|Kotlin}}
<syntaxhighlight lang=Nim"nim">
import strformat
 
Line 1,039:
=={{header|Objeck}}==
{{trans|Java}}
<syntaxhighlight lang="objeck">class DigitalFilter {
function : Main(args : String[]) ~ Nil {
a := [1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17];
Line 1,090:
 
=={{header|ooRexx}}==
<syntaxhighlight lang="oorexx">/* REXX */
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)
Line 1,151:
=={{header|Perl}}==
{{trans|Raku}}
<syntaxhighlight lang="perl">use strict;
use List::AllUtils 'natatime';
 
Line 1,193:
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...
<!--<syntaxhighlight lang=Phix"phix">(phixonline)-->
<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>
Line 1,223:
=={{header|Phixmonti}}==
{{trans|Phix}}
<syntaxhighlight lang=Phixmonti"phixmonti">include ..\Utilitys.pmt
 
( 1.00000000 -2.77555756e-16 3.33333333e-01 -1.85037171e-17 ) var a
Line 1,254:
=={{header|Python}}==
 
<syntaxhighlight lang="python">#!/bin/python
from __future__ import print_function
from scipy import signal
Line 1,287:
{{trans|C}} Strangely, C was more informative than Common Lisp in helping figure out what was going on here.
 
<syntaxhighlight lang="racket">#lang racket
 
(define a (vector 1.00000000E0 -2.77555756E-16 3.33333333E-01 -1.85037171E-17))
Line 1,338:
{{trans|zkl}}
 
<syntaxhighlight lang=perl6"raku" line>sub TDF-II-filter ( @signal, @a, @b ) {
my @out = 0 xx @signal;
for ^@signal -> $i {
Line 1,371:
===version 1===
{{trans|Julia}}
<syntaxhighlight lang=REXX"rexx">/*REXX pgm filters a signal with a order3 lowpass Butterworth, direct form II transposed*/
@a= '1 -2.77555756e-16 3.33333333e-1 -1.85037171e-17' /*filter coefficients*/
@b= 0.16666667 0.5 0.5 0.16666667 /* " " */
Line 1,413:
===version 2===
{{trans|Julia}}
<syntaxhighlight lang=REXX"rexx">/* REXX */
Numeric Digits 24
acoef = '1.00000000, -2.77555756e-16, 3.33333333e-01, -1.85037171e-17'
Line 1,470:
=={{header|Ruby}}==
{{trans|C#}}
<syntaxhighlight lang="ruby">def filter(a,b,signal)
result = Array.new(signal.length(), 0.0)
for i in 0..signal.length()-1 do
Line 1,519:
=={{header|Rust}}==
{{trans|Java}}
<syntaxhighlight lang=Rust"rust">use std::cmp::Ordering;
 
struct IIRFilter<'f>(&'f [f32], &'f [f32]);
Line 1,636:
{{libheader|Scastie qualified}}
{{works with|Scala|2.13}}
<syntaxhighlight lang=Scala"scala">object ButterworthFilter extends App {
private def filter(a: Vector[Double],
b: Vector[Double],
Line 1,675:
=={{header|Sidef}}==
{{trans|Raku}}
<syntaxhighlight lang="ruby">func TDF_II_filter(signal, a, b) {
var out = [0]*signal.len
for i in ^signal {
Line 1,712:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Module Module1
 
Function Filter(a As Double(), b As Double(), signal As Double()) As Double()
Line 1,764:
=={{header|Vlang}}==
{{trans|Go}}
<syntaxhighlight lang="vlang">struct Filter {
b []f64
a []f64
Line 1,840:
{{trans|Kotlin}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascript">import "/fmt" for Fmt
 
var filter = Fn.new { |a, b, signal|
Line 1,887:
=={{header|Yabasic}}==
{{trans|D}}
<syntaxhighlight lang=Yabasic"yabasic">sub filter(a(), b(), signal(), result())
local i, j, tmp
Line 1,935:
=={{header|zkl}}==
{{trans|C++}}
<syntaxhighlight lang="zkl">fcn direct_form_II_transposed_filter(b,a,signal){
out:=List.createLong(signal.len(),0.0); // vector of zeros
foreach i in (signal.len()){
Line 1,945:
out
}</syntaxhighlight>
<syntaxhighlight lang="zkl">signal:=T(-0.917843918645, 0.141984778794, 1.20536903482, 0.190286794412,
-0.662370894973,-1.00700480494, -0.404707073677, 0.800482325044,
0.743500089861, 1.01090520172, 0.741527555207, 0.277841675195,
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328957"