Initial Commit

.gitignore

+# CLion
+/.idea
+/*-build-*
+
+# Visual Studio
+/.vs
+/out
+
+# vscode
+/.vscode
+/build

CMakeLists.txt

+cmake_minimum_required(VERSION 3.26)
+project(Uebung5)
+
+set(CMAKE_CXX_STANDARD 14)
+
+add_executable(Uebung5 src/main.cpp
+        src/filter2.h
+        src/filter2.cpp
+        src/filter.h
+        src/filter.cpp
+)
+
+# Fetch Catch2
+Include(FetchContent)
+FetchContent_Declare(
+        Catch2
+        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+        GIT_TAG        v3.4.0
+)
+FetchContent_MakeAvailable(Catch2)
+enable_testing()
+
+add_executable(test_filter2
+        src/filter2.h
+        src/filter2.cpp
+        src/filter2.test.cpp
+)
+add_executable(test_filter
+        src/filter.h
+        src/filter.cpp
+        src/filter.test.cpp
+)
+target_link_libraries(test_filter2 PRIVATE Catch2::Catch2WithMain)
+target_link_libraries(test_filter PRIVATE Catch2::Catch2WithMain)
+target_include_directories(test_filter2 PRIVATE src/)
+target_include_directories(test_filter PRIVATE src/)
+add_test(test_filter2 env CTEST_OUTPUT_ON_FAILURE=1 ./test_filter2)
+add_test(test_filter env CTEST_OUTPUT_ON_FAILURE=1 ./test_filter)

src/filter.cpp

+#include "filter.h"

src/filter.h

+#ifndef FILTER_H
+#define FILTER_H
+
+#include <iostream>
+
+class Filter {
+   public:
+    Filter(double a1, double a0, double b2, double b1, double b0){
+    }
+
+    ~Filter() {
+    }
+
+    Filter(const Filter& other){
+    }
+
+    Filter& operator=(const Filter& other) {
+        return *this;
+    }
+
+    size_t order() const { return 0; }
+
+    double initialize(double u0) {
+        return 0;
+    }
+
+    double step(double u) {
+        return 0;
+    }
+
+    Filter operator*(const Filter& other) const {
+        Filter prod{0,0,0,0,0};
+
+        return prod;
+    }
+
+    static Filter From_continuous_first_order(double a_0, double ts) {
+        return Filter{0,0,0,0,0};
+    }
+
+    static Filter From_continuous_second_order(double a_1, double a_0,
+                                               double ts) {
+
+        return Filter{0,0,0,0,0};
+    }
+
+};
+
+#endif  // FILTER_H

src/filter.test.cpp

+#include "filter.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+
+TEST_CASE("static_gain") {
+    Filter filter{0.0, 0.0, 10.0, 0.0, 0.0};
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (const auto u : us) {
+        const double y = filter.step(u);
+
+        CHECK(y == 10.0 * u);
+    }
+}
+
+TEST_CASE("static_delay_zero_initialized") {
+    Filter filter{0.0, 0.0, 0.0, 0.0, 10.0};
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0, 0.0, 0.0};
+    const double us_delayed[]{0.0, 0.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (size_t i = 0; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        CHECK(y == 10.0 * us_delayed[i]);
+    }
+}
+
+TEST_CASE("static_delay_initialized") {
+    Filter filter{0.0, 0.0, 0.0, 0.0, 10.0};
+    filter.initialize(10.0);
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0, 0.0, 0.0};
+    const double us_delayed[]{10.0, 10.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (size_t i = 0; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        CHECK(y == 10.0 * us_delayed[i]);
+    }
+}
+
+TEST_CASE("zero_initialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    Filter filter{a1, a0, b2, b1, b0};
+
+    const double us[]{0.0, 0.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("initialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    const double k = (b2 + b1 + b0) / (1.0 + a1 + a0);
+    const double u0 = -7.0;
+    const double y0c = u0 * k;
+
+    Filter filter{a1, a0, b2, b1, b0};
+    const double y0 = filter.initialize(u0);
+
+    REQUIRE(y0 == y0c);
+
+    const double us[]{u0, u0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{y0c, y0c, 0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("reinitialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    const double k = (b2 + b1 + b0) / (1.0 + a1 + a0);
+    const double u0 = -7.0;
+    const double y0c = u0 * k;
+
+    Filter filter{a1, a0, b2, b1, b0};
+    const double y0 = filter.initialize(u0);
+
+    REQUIRE(y0 == y0c);
+
+    const double us[]{u0, u0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{y0c, y0c, 0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+
+    const double y0r = filter.initialize(u0);
+    REQUIRE(y0r == y0c);
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("pt1") {
+    Filter filter = Filter::From_continuous_first_order(10.0, 0.01);
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        4.7619047619047616e-02, 1.3832199546485260e-01, 2.2038656732534281e-01,
+        2.9463546567531013e-01, 3.6181304037289957e-01, 4.2259275081357578e-01,
+        4.7758391740275896e-01, 5.2733783003106760e-01, 5.7235327479001352e-01,
+        6.1308153433382173e-01, 6.4993091201631481e-01, 6.8327082515761806e-01,
+        7.1343550847594006e-01, 7.4072736481156476e-01, 7.6541999673427275e-01,
+        7.8776094942624664e-01, 8.0797419233803258e-01, 8.2626236449631507e-01,
+        8.4280880597285635e-01, 8.5777939588020324e-01, 8.7132421532018378e-01,
+        8.8357905195635666e-01, 8.9466676129384637e-01, 9.0469849831347993e-01,
+        9.1377483180743413e-01, 9.2198675258767837e-01, 9.2941658567456609e-01,
+        9.3613881561032164e-01, 9.4222083317124328e-01, 9.4772361096445812e-01,
+        9.5270231468212863e-01, 9.5720685614097345e-01, 9.6128239365135681e-01,
+        9.6496978473217987e-01, 9.6830599571006737e-01, 9.7132447230910846e-01,
+        9.7405547494633615e-01, 9.7652638209430398e-01, 9.7876196475198918e-01,
+        9.8078463477560918e-01, 9.8261466955888443e-01, 9.8427041531518100e-01,
+        9.8576847099944942e-01, 9.8712385471378750e-01, 9.8835015426485529e-01,
+        9.8945966338248803e-01, 9.9046350496510815e-01, 9.9137174258747873e-01,
+        9.9219348138867114e-01, 9.9293695935165471e-01, 9.9360962988959223e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("pt2") {
+    Filter filter = Filter::From_continuous_second_order(20.0, 100.0, 0.01);
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        2.2675736961451248e-03, 1.0905949681459887e-02, 2.6948647939901586e-02,
+        4.8906968755180150e-02, 7.5508614876030125e-02, 1.0566997494433562e-01,
+        1.3847172343612915e-01, 1.7313735679620385e-01, 2.0901432780709311e-01,
+        2.4555747797421931e-01, 2.8231450132668118e-01, 3.1891320297051790e-01,
+        3.5505034238444760e-01, 3.9048187517104815e-01, 4.2501442808551215e-01,
+        4.5849786094215494e-01, 4.9081878569834420e-01, 5.2189492786204250e-01,
+        5.5167022856418979e-01, 5.8011059736060344e-01, 6.0720023624056474e-01,
+        6.3293846456415614e-01, 6.5733698285567532e-01, 6.8041752066024630e-01,
+        7.0220982012693378e-01, 7.2274991270508915e-01, 7.4207865141233120e-01,
+        7.6024046562472358e-01, 7.7728230931672992e-01, 7.9325277719778986e-01,
+        8.0820136630498152e-01, 8.2217786336275100e-01, 8.3523184065164857e-01,
+        8.4741224527451819e-01, 8.5876706860276741e-01, 8.6934308435579910e-01,
+        8.7918564523884057e-01, 8.8833852936088753e-01, 8.9684382879538971e-01,
+        9.0474187364952519e-01, 9.1207118588930958e-01, 9.1886845794147498e-01,
+        9.2516855177155621e-01, 9.3100451473203960e-01, 9.3640760899463926e-01,
+        9.4140735183550095e-01, 9.4603156443914971e-01, 9.5030642723316483e-01,
+        9.5425654006696725e-01, 9.5790498581013017e-01, 9.6127339617303575e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("pt1 * pt1") {
+    Filter pt1 = Filter::From_continuous_first_order(10.0, 0.01);
+
+    Filter filter = pt1 * pt1;
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        2.2675736961451248e-03, 1.0905949681459887e-02, 2.6948647939901586e-02,
+        4.8906968755180150e-02, 7.5508614876030125e-02, 1.0566997494433562e-01,
+        1.3847172343612915e-01, 1.7313735679620385e-01, 2.0901432780709311e-01,
+        2.4555747797421931e-01, 2.8231450132668118e-01, 3.1891320297051790e-01,
+        3.5505034238444760e-01, 3.9048187517104815e-01, 4.2501442808551215e-01,
+        4.5849786094215494e-01, 4.9081878569834420e-01, 5.2189492786204250e-01,
+        5.5167022856418979e-01, 5.8011059736060344e-01, 6.0720023624056474e-01,
+        6.3293846456415614e-01, 6.5733698285567532e-01, 6.8041752066024630e-01,
+        7.0220982012693378e-01, 7.2274991270508915e-01, 7.4207865141233120e-01,
+        7.6024046562472358e-01, 7.7728230931672992e-01, 7.9325277719778986e-01,
+        8.0820136630498152e-01, 8.2217786336275100e-01, 8.3523184065164857e-01,
+        8.4741224527451819e-01, 8.5876706860276741e-01, 8.6934308435579910e-01,
+        8.7918564523884057e-01, 8.8833852936088753e-01, 8.9684382879538971e-01,
+        9.0474187364952519e-01, 9.1207118588930958e-01, 9.1886845794147498e-01,
+        9.2516855177155621e-01, 9.3100451473203960e-01, 9.3640760899463926e-01,
+        9.4140735183550095e-01, 9.4603156443914971e-01, 9.5030642723316483e-01,
+        9.5425654006696725e-01, 9.5790498581013017e-01, 9.6127339617303575e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-6));
+    }
+}
+
+TEST_CASE("pt1 * pt2") {
+    Filter pt1 = Filter::From_continuous_first_order(10.0, 0.01);
+    Filter pt2 = Filter::From_continuous_second_order(40.0, 400.0, 0.01);
+
+    Filter filter = pt1 * pt2;
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        3.9354584809130262e-04, 2.5742327985539318e-03, 8.4501693082014769e-03,
+        1.9325217042412170e-02, 3.5647932227125229e-02, 5.7304151221240461e-02,
+        8.3829106535630402e-02, 1.1455888645276452e-01, 1.4873648545881180e-01,
+        1.8558413414971686e-01, 2.2435083053681135e-01, 2.6434184928665838e-01,
+        3.0493534674449707e-01, 3.4558990140588575e-01, 3.8584584815615286e-01,
+        4.2532251428717283e-01, 4.6371289434823704e-01, 5.0077686877924465e-01,
+        5.3633374630898201e-01, 5.7025466752381748e-01, 6.0245522753505643e-01,
+        6.3288854430569386e-01, 6.6153890431995566e-01, 6.8841604991279060e-01,
+        7.1355012580615285e-01, 7.3698727091899474e-01, 7.5878582127537231e-01,
+        7.7901307774902839e-01, 7.9774258612453763e-01, 8.1505187477607077e-01,
+        8.3102059586245403e-01, 8.4572901835019876e-01, 8.5925682470327447e-01,
+        8.7168216721535774e-01, 8.8308094435125273e-01, 8.9352626186417916e-01,
+        9.0308804770190776e-01, 9.1183279370475645e-01, 9.1982340077334224e-01,
+        9.2711910751579019e-01, 9.3377548536651311e-01, 9.3984448580991276e-01,
+        9.4537452766003438e-01, 9.5041061436456198e-01, 9.5499447304473228e-01,
+        9.5916470847895663e-01, 9.6295696651409324e-01, 9.6640410247020980e-01,
+        9.6953635101643820e-01, 9.7238149475937596e-01, 9.7496502942154384e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-6));
+    }
+}
+
+TEST_CASE("pt2 * pt2 * pt2") {
+    Filter pt2a = Filter::From_continuous_second_order(20.0, 100.0, 0.01);
+    Filter pt2b = Filter::From_continuous_second_order(40.0, 400.0, 0.01);
+    Filter pt2c = Filter::From_continuous_second_order(5.0, 100.0, 0.01);
+
+    Filter filter = pt2a * pt2b * pt2c;
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        4.5596784624180589e-08, 5.6482986336346723e-07, 3.4948380088479331e-06,
+        1.4573818177582623e-05, 4.6587253796815764e-05, 1.2287245182105436e-04,
+        2.8038502028261735e-04, 5.7189482994746956e-04, 1.0671214538845715e-03,
+        1.8527812037214396e-03, 3.0316214062884434e-03, 4.7205789043472156e-03,
+        7.0482312474487380e-03, 1.0151719855418817e-02, 1.4173321383819501e-02,
+        1.9256831572541717e-02, 2.5543908611703754e-02, 3.3170503072871456e-02,
+        4.2263480513530745e-02, 5.2937522180185888e-02, 6.5292369600749370e-02,
+        7.9410460754833170e-02, 9.5354989207470667e-02, 1.1316840320062140e-01,
+        1.3287134922534938e-01, 1.5446205398399016e-01, 1.7791612979023153e-01,
+        2.0318678121471645e-01, 2.3020538502099608e-01, 2.5888241100437603e-01,
+        2.8910864809981252e-01, 3.2075669792614014e-01, 3.5368269665260044e-01,
+        3.8772822558949993e-01, 4.2272237110743827e-01, 4.5848389527831024e-01,
+        4.9482347991504294e-01, 5.3154600838345434e-01, 5.6845285159451808e-01,
+        6.0534412689195516e-01, 6.4202090106842913e-01, 6.7828731141981702e-01,
+        7.1395258153267516e-01, 7.4883291135172303e-01, 7.8275322395305824e-01,
+        8.1554875432015794e-01, 8.4706646825255294e-01, 8.7716630230393366e-01,
+        9.0572221832313449e-01, 9.3262306873676326e-01, 9.5777327114786803e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-6));
+    }
+}

src/filter2.cpp

+#include "filter2.h"

src/filter2.h

+#ifndef FILTER2_H
+#define FILTER2_H
+
+#include <cmath>
+
+class Filter2 {
+   public:
+    Filter2(double a1, double a0, double b2, double b1, double b0){}
+
+    double initialize(double u0) {return 0;}
+
+    double step(double u) {
+        return 0;
+    }
+
+    static Filter2 From_continuous_first_order(double a_0, double ts) {
+        return Filter2{0,0,0,0,0};
+    }
+
+    static Filter2 From_continuous_second_order(double a_1, double a_0,
+                                                double ts) {
+        return Filter2{0,0,0,0,0};
+    }
+
+};
+
+#endif  // FILTER_H

src/filter2.test.cpp

+#include "filter2.h"
+
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+
+TEST_CASE("static_gain") {
+    Filter2 filter{0.0, 0.0, 10.0, 0.0, 0.0};
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (const auto u : us) {
+        const double y = filter.step(u);
+
+        CHECK(y == 10.0 * u);
+    }
+}
+
+TEST_CASE("static_delay_zero_initialized") {
+    Filter2 filter{0.0, 0.0, 0.0, 0.0, 10.0};
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0, 0.0, 0.0};
+    const double us_delayed[]{0.0, 0.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (size_t i = 0; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        CHECK(y == 10.0 * us_delayed[i]);
+    }
+}
+
+TEST_CASE("static_delay_initialized") {
+    Filter2 filter{0.0, 0.0, 0.0, 0.0, 10.0};
+    filter.initialize(10.0);
+
+    const double us[]{1.0, 2.0, -1.0, 0.0, 5.0, 0.0, 0.0};
+    const double us_delayed[]{10.0, 10.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+
+    for (size_t i = 0; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        CHECK(y == 10.0 * us_delayed[i]);
+    }
+}
+
+TEST_CASE("zero_initialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    Filter2 filter{a1, a0, b2, b1, b0};
+
+    const double us[]{0.0, 0.0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("initialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    const double k = (b2 + b1 + b0) / (1.0 + a1 + a0);
+    const double u0 = -7.0;
+    const double y0c = u0 * k;
+
+    Filter2 filter{a1, a0, b2, b1, b0};
+    const double y0 = filter.initialize(u0);
+
+    REQUIRE(y0 == y0c);
+
+    const double us[]{u0, u0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{y0c, y0c, 0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("reinitialized") {
+    const double a1 = 4.0;
+    const double a0 = 3.0;
+    const double b2 = 2.0;
+    const double b1 = 10.0;
+    const double b0 = 5.0;
+
+    const double k = (b2 + b1 + b0) / (1.0 + a1 + a0);
+    const double u0 = -7.0;
+    const double y0c = u0 * k;
+
+    Filter2 filter{a1, a0, b2, b1, b0};
+    const double y0 = filter.initialize(u0);
+
+    REQUIRE(y0 == y0c);
+
+    const double us[]{u0, u0, 1.0, 2.0, -1.0, 0.0, 5.0};
+    double ys[7]{y0c, y0c, 0.0};
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+
+    const double y0r = filter.initialize(u0);
+    REQUIRE(y0r == y0c);
+
+    for (size_t i = 2; i < 7; ++i) {
+        const double y = filter.step(us[i]);
+
+        ys[i] = -a1 * ys[i - 1] - a0 * ys[i - 2] + b2 * us[i] + b1 * us[i - 1] +
+                b0 * us[i - 2];
+
+        CHECK_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("pt1") {
+    Filter2 filter = Filter2::From_continuous_first_order(10.0, 0.01);
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        4.7619047619047616e-02, 1.3832199546485260e-01, 2.2038656732534281e-01,
+        2.9463546567531013e-01, 3.6181304037289957e-01, 4.2259275081357578e-01,
+        4.7758391740275896e-01, 5.2733783003106760e-01, 5.7235327479001352e-01,
+        6.1308153433382173e-01, 6.4993091201631481e-01, 6.8327082515761806e-01,
+        7.1343550847594006e-01, 7.4072736481156476e-01, 7.6541999673427275e-01,
+        7.8776094942624664e-01, 8.0797419233803258e-01, 8.2626236449631507e-01,
+        8.4280880597285635e-01, 8.5777939588020324e-01, 8.7132421532018378e-01,
+        8.8357905195635666e-01, 8.9466676129384637e-01, 9.0469849831347993e-01,
+        9.1377483180743413e-01, 9.2198675258767837e-01, 9.2941658567456609e-01,
+        9.3613881561032164e-01, 9.4222083317124328e-01, 9.4772361096445812e-01,
+        9.5270231468212863e-01, 9.5720685614097345e-01, 9.6128239365135681e-01,
+        9.6496978473217987e-01, 9.6830599571006737e-01, 9.7132447230910846e-01,
+        9.7405547494633615e-01, 9.7652638209430398e-01, 9.7876196475198918e-01,
+        9.8078463477560918e-01, 9.8261466955888443e-01, 9.8427041531518100e-01,
+        9.8576847099944942e-01, 9.8712385471378750e-01, 9.8835015426485529e-01,
+        9.8945966338248803e-01, 9.9046350496510815e-01, 9.9137174258747873e-01,
+        9.9219348138867114e-01, 9.9293695935165471e-01, 9.9360962988959223e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}
+
+TEST_CASE("pt2") {
+    Filter2 filter = Filter2::From_continuous_second_order(20.0, 100.0, 0.01);
+
+    const double u = 1.0;
+    constexpr size_t N = 51;
+    const double ys[N] = {
+        2.2675736961451248e-03, 1.0905949681459887e-02, 2.6948647939901586e-02,
+        4.8906968755180150e-02, 7.5508614876030125e-02, 1.0566997494433562e-01,
+        1.3847172343612915e-01, 1.7313735679620385e-01, 2.0901432780709311e-01,
+        2.4555747797421931e-01, 2.8231450132668118e-01, 3.1891320297051790e-01,
+        3.5505034238444760e-01, 3.9048187517104815e-01, 4.2501442808551215e-01,
+        4.5849786094215494e-01, 4.9081878569834420e-01, 5.2189492786204250e-01,
+        5.5167022856418979e-01, 5.8011059736060344e-01, 6.0720023624056474e-01,
+        6.3293846456415614e-01, 6.5733698285567532e-01, 6.8041752066024630e-01,
+        7.0220982012693378e-01, 7.2274991270508915e-01, 7.4207865141233120e-01,
+        7.6024046562472358e-01, 7.7728230931672992e-01, 7.9325277719778986e-01,
+        8.0820136630498152e-01, 8.2217786336275100e-01, 8.3523184065164857e-01,
+        8.4741224527451819e-01, 8.5876706860276741e-01, 8.6934308435579910e-01,
+        8.7918564523884057e-01, 8.8833852936088753e-01, 8.9684382879538971e-01,
+        9.0474187364952519e-01, 9.1207118588930958e-01, 9.1886845794147498e-01,
+        9.2516855177155621e-01, 9.3100451473203960e-01, 9.3640760899463926e-01,
+        9.4140735183550095e-01, 9.4603156443914971e-01, 9.5030642723316483e-01,
+        9.5425654006696725e-01, 9.5790498581013017e-01, 9.6127339617303575e-01,
+    };
+
+    for (size_t i = 0; i < N; ++i) {
+        const double y = filter.step(u);
+
+        REQUIRE_THAT(y, Catch::Matchers::WithinAbs(ys[i], 1e-12));
+    }
+}

src/main.cpp

+#include <iostream>
+
+#include "filter2.h"
+
+int main() {
+    Filter2 filter{0.0, 0.0, 0.5, 0.5, 0.0};
+
+    const double u0 = 3.0;
+    const double y0 = filter.initialize(u0);
+
+    std::cout << "init: u0 = " << u0 << " -> y0 = " << y0 << "\n";
+
+    const double us[] = {1.0, 2.0, 3.0, 0.5};
+
+    for (const double u : us) {
+        const double y = filter.step(u);
+
+        std::cout << "u(k) = " << u << " -> y(k) = " << y << "\n";
+    }
+
+    return 0;
+}