ContinuousTransferFunction.hpp

Go to the documentation of this file.

#pragma once
 
#include "Polynom.hpp"
#include "TransferFunction.hpp"
 
namespace controlpp
{
 
    template<class T, int NumOrder, int DenOrder>
    class ContinuousTransferFunction{
        public:
            using value_type = T;
            using transfer_function_type = TransferFunction<T, NumOrder, DenOrder>;
            using num_type = typename transfer_function_type::num_type;
            using den_type = typename transfer_function_type::den_type;
            using num_vector_type = typename transfer_function_type::num_vector_type;
            using den_vector_type = typename transfer_function_type::den_vector_type;
 
        private:
            TransferFunction<T, NumOrder, DenOrder> tf_;
        public:
 
            ContinuousTransferFunction() = default;
            ContinuousTransferFunction(const ContinuousTransferFunction&) = default;
            ContinuousTransferFunction& operator=(const ContinuousTransferFunction&) = default;
 
            explicit ContinuousTransferFunction(const Polynom<T, NumOrder>& num, const Polynom<T, DenOrder>& den)
                : tf_(num, den){}
 
            explicit ContinuousTransferFunction(const TransferFunction<T, NumOrder, DenOrder>& transfer_function)
                : tf_(transfer_function){}
 
            explicit ContinuousTransferFunction(const Eigen::Vector<T, NumOrder+1>& num, const Eigen::Vector<T, DenOrder+1>& den)
                : tf_(num, den){}
 
            explicit ContinuousTransferFunction(const T(&num)[NumOrder+1], const T(&den)[DenOrder+1])
                : tf_(num, den){}
 
            num_type& num() {return this->tf_.num();}
            const num_type& num() const {return this->tf_.num();}
 
            T& num(size_t i) {return this->tf_.num(i);}
            const T& num(size_t i) const {return this->tf_.num(i);}
 
            den_type& den() {return this->tf_.den();}
            const den_type& den() const {return this->tf_.den();}
 
            T& den(size_t i) {return this->tf_.den(i);}
            const T& den(size_t i) const {return this->tf_.den(i);}
 
            transfer_function_type& transfer_function() {return this->tf_;}
            const transfer_function_type& transfer_function() const {return this->tf_;}
 
            T eval(const T& x) const {
                return this->tf_.eval(x);
            }
 
            template<int M>
            Eigen::Vector<T, M> eval(const Eigen::Vector<T, M>& x_vec) const {
                return this->tf_.eval(x_vec);
            }
 
            std::complex<T> eval(const std::complex<T>& x) const {
                return this->tf_.eval(x);
            }
 
            template<int M>
            Eigen::Vector<std::complex<T>, M> eval(const Eigen::Vector<std::complex<T>, M>& x_vec) const {
                return this->tf_.eval(x_vec);
            }
 
            std::complex<T> eval_frequency(const T& frequency) const {
                return this->tf_.eval_frequency(frequency);
            }
 
            std::complex<T> eval_frequency_Hz(const T& frequency) const {
                return this->tf_.eval_frequency_Hz(frequency);
            }
 
            template<int M>
            Eigen::Vector<std::complex<T>, M> eval_frequencies(const Eigen::Vector<T, M>& frequencies) const {
                return this->tf_.eval_frequencies(frequencies);
            }
 
            template<int M>
            Eigen::Vector<std::complex<T>, M> eval_frequencies_hz(const Eigen::Vector<T, M>& frequencies) const {
                return this->tf_.eval_frequencies_hz(frequencies);
            }
 
            friend std::ostream& operator<<(std::ostream& stream, const ContinuousTransferFunction& ctf){
                ctf.transfer_function().print(stream, "s");
                return stream;
            }
    };
 
    // operator +
    // -----------
 
    template<class T, int NumOrder1, int DenOrder1, int NumOrder2, int DenOrder2>
    auto operator+(const ContinuousTransferFunction<T, NumOrder1, DenOrder1>& lhs, const ContinuousTransferFunction<T, NumOrder2, DenOrder2>& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() + rhs.transfer_function());
    }
 
    template<class Tpoly, class Tscalar, int NumOrder, int DenOrder>
    auto operator+(const Tscalar& lhs, const ContinuousTransferFunction<Tpoly, NumOrder, DenOrder>& rhs){
        return ContinuousTransferFunction(lhs + rhs.transfer_function());
    }
 
    template<class Tpoly, class Tscalar, int NumOrder, int DenOrder>
    auto operator+(const ContinuousTransferFunction<Tpoly, NumOrder, DenOrder>& lhs, const Tscalar& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() + rhs);
    }
 
    // operator -
    // -----------
 
    template<class T, int NumOrder, int DenOrder>
    ContinuousTransferFunction<T, NumOrder, DenOrder> operator-(const ContinuousTransferFunction<T, NumOrder, DenOrder>& a){
        return ContinuousTransferFunction(-a.transfer_function());
    }
 
    template<class T, int NumOrder1, int DenOrder1, int NumOrder2, int DenOrder2>
    auto operator-(const ContinuousTransferFunction<T, NumOrder1, DenOrder1>& lhs, const ContinuousTransferFunction<T, NumOrder2, DenOrder2>& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() - rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator-(const Tscalar& lhs, const ContinuousTransferFunction<T, NumOrder, DenOrder>& rhs){
        return ContinuousTransferFunction(lhs - rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator-(const ContinuousTransferFunction<T, NumOrder, DenOrder>& lhs, const Tscalar& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() - rhs);
    }
 
    // operator *
    // -----------
 
    template<class T, int NumOrder1, int DenOrder1, int NumOrder2, int DenOrder2>
    auto operator*(const ContinuousTransferFunction<T, NumOrder1, DenOrder1>& lhs, const ContinuousTransferFunction<T, NumOrder2, DenOrder2>& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() * rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator*(const Tscalar& lhs, const ContinuousTransferFunction<T, NumOrder, DenOrder>& rhs){
        return ContinuousTransferFunction(lhs * rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator*(const ContinuousTransferFunction<T, NumOrder, DenOrder>& lhs, const Tscalar& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() * rhs);
    }
 
    // operator /
    // -----------
 
    template<class T, int NumOrder1, int DenOrder1, int NumOrder2, int DenOrder2>
    auto operator/(const ContinuousTransferFunction<T, NumOrder1, DenOrder1>& lhs, const ContinuousTransferFunction<T, NumOrder2, DenOrder2>& rhs){
        return ContinuousTransferFunction(lhs.transfer_function() / rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator/(const Tscalar& lhs, const ContinuousTransferFunction<T, NumOrder, DenOrder>& rhs){
        return ContinuousTransferFunction(lhs / rhs.transfer_function());
    }
 
    template<class T, class Tscalar, int NumOrder, int DenOrder>
    auto operator/(const ContinuousTransferFunction<T, NumOrder, DenOrder>& lhs, const Tscalar& rhs){
        ContinuousTransferFunction result(lhs.transfer_function() / rhs);
        return result;
    }
 
    namespace tf{
        template<class T=double>
        static inline const ContinuousTransferFunction<T, 1, 0> s({T(0), T(1)}, {T(1)});
    }
 
// analysis
 
    template<class T, int NumOrder, int DenOrder>
    Eigen::Vector<std::complex<T>, NumOrder> zeros(const ContinuousTransferFunction<T, NumOrder, DenOrder>& tf){
        const Eigen::Vector<std::complex<T>, NumOrder> result = zeros(tf.num());
        return result;
    }   
 
    template<class T, int NumOrder, int DenOrder>
    Eigen::Vector<std::complex<T>, DenOrder> poles(const ContinuousTransferFunction<T, NumOrder, DenOrder>& tf){
        const Eigen::Vector<std::complex<T>, DenOrder> result = zeros(tf.den());
        return result;
    }
 
} // namespace controlpp