C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Physics/ButterworthFilter.cs

//-----------------------------------------------------------------------------
// ButterworthFilter.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.Physics
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    public enum ButterworthFilterType
    {
        LowPass,

        HighPass,
    }

    public class ButterworthFilter
    {
        static public double DefaultResonance = Math.Sqrt(2.0);

        private double a1;

        private double a2;

        private double a3;

        private double b1;

        private double b2;

        public ButterworthFilter(
            ButterworthFilterType filterType,
            double sampleRate,
            double cutoffFrequency) : this(filterType, sampleRate, cutoffFrequency, DefaultResonance) 
        {
        }

        public ButterworthFilter(
            ButterworthFilterType filterType,
            double sampleRate,
            double cutoffFrequency,
            double resonance)
        {
            // Check input parameters
            if (sampleRate <= 0.0)
            {
                throw new ArgumentException("The sample rate cannot be zero or negative.");
            }

            if ((cutoffFrequency <= 0.0) || 
                (cutoffFrequency > (sampleRate / 2.0)))
            {
                throw new ArgumentException("The cutoff frequency should be greater than " +
                    "zero, but less than half the sample rate");
            }

            if ((resonance < 0.1) || (resonance > DefaultResonance))
            {
                throw new ArgumentException("The resonance parameter should be in " +
                    " the range 0.1 to sqrt(2)");
            }

            // Calculate filter parameters
            switch (filterType)
            {
                case ButterworthFilterType.LowPass:
                    this.InitializeLowPass(sampleRate, cutoffFrequency, resonance);
                    break;
                case ButterworthFilterType.HighPass:
                    this.InitializeHighPass(sampleRate, cutoffFrequency, resonance);
                    break;
            }
        }

        private void InitializeLowPass(
            double sampleRate,
            double cutoffFrequency,
            double resonance)
        {
            double c = 1.0 / Math.Tan(Math.PI * cutoffFrequency / sampleRate);
            this.a1 = 1.0 / (1.0 + resonance * c + c * c);
            this.a2 = 2 * this.a1;
            this.a3 = this.a1;
            this.b1 = 2.0 * (1.0 - c * c) * this.a1;
            this.b2 = (1.0 - resonance * c + c * c) * this.a1;
        }

        private void InitializeHighPass(
            double sampleRate,
            double cutoffFrequency,
            double resonance)
        {
            double c = Math.Tan(Math.PI * cutoffFrequency / sampleRate);
            this.a1 = 1.0 / (1.0 + resonance * c + c * c);
            this.a2 = -2 * this.a1;
            this.a3 = this.a1;
            this.b1 = 2.0 * (c * c - 1.0) * this.a1;
            this.b2 = (1.0 - resonance * c + c * c) * this.a1;
        }

        public double[] Calculate(
            double[] samples)
        {
            if (samples == null)
            {
                throw new ArgumentNullException("samples");
            }

            int nMax = samples.Length;
            if (nMax < 3)
            {
                throw new ArgumentException(
                    "samples", 
                    "The samples array must contain at least 3 values.");
            }

            double[] filteredSamples = new double[nMax];
            filteredSamples[0] = 0.0;
            filteredSamples[1] = 0.0;
            for (int n = 2; n < nMax; n++)
            {
                filteredSamples[n] =
                    this.a1 * samples[n] +
                    this.a2 * samples[n - 1] +
                    this.a3 * samples[n - 2] -
                    this.b1 * filteredSamples[n - 1] -
                    this.b2 * filteredSamples[n - 2];
            }

            return filteredSamples;
        }
    }
}

---