ContinuousStateSpace.hpp

Go to the documentation of this file.

#pragma once
 
#include "StateSpace.hpp"
#include "TransferFunction.hpp"
#include "ContinuousTransferFunction.hpp"
 
namespace controlpp
{
    template<class T, int internal_states, int inputs=1, int outputs=1>
    class ContinuousStateSpace{
        public:
            using value_type = T;
 
            using state_space_type = StateSpace<T, internal_states, inputs, outputs>;
 
            using A_matrix_type = typename state_space_type::A_matrix_type;
            using B_matrix_type = typename state_space_type::B_matrix_type;
            using C_matrix_type = typename state_space_type::C_matrix_type;
            using D_matrix_type = typename state_space_type::D_matrix_type;
 
            constexpr static int number_of_states = internal_states;
            constexpr static int number_of_inputs = inputs;
            constexpr static int number_of_outputs = outputs;
 
        private:
            state_space_type _state_space;
 
        public:
            ContinuousStateSpace() = default;
            ContinuousStateSpace(const ContinuousStateSpace&) = default;
            ContinuousStateSpace& operator=(const ContinuousStateSpace&) = default;
 
            ContinuousStateSpace(
                const Eigen::Matrix<T, internal_states, internal_states>& A,
                const Eigen::Matrix<T, internal_states, inputs>& B,
                const Eigen::Matrix<T, outputs, internal_states>& C,
                const Eigen::Matrix<T, outputs, inputs>& D = Eigen::Matrix<T, outputs, inputs>::Zero()
            ) : _state_space(A, B, C, D){}
 
            ContinuousStateSpace(const StateSpace<T, internal_states, inputs, outputs>& state_space) : _state_space(state_space){}
            
            StateSpace<T, internal_states, inputs, outputs>& state_space(){return this->_state_space;}
            const StateSpace<T, internal_states, inputs, outputs>& state_space() const {return this->_state_space;}
 
            std::tuple<Eigen::Vector<T, internal_states>, Eigen::Vector<T, outputs>> eval(const Eigen::Vector<T, internal_states>& x, const Eigen::Vector<T, inputs>& u) const {
                this->_state_space(x, u);
            }
 
            template<std::same_as<T> U>
                requires(inputs == 1)
            std::tuple<Eigen::Vector<U, internal_states>, Eigen::Vector<U, outputs>> eval(const Eigen::Vector<U, internal_states>& x, const U& u_scalar) const {
                this->_state_space(x, u_scalar);
            }
 
            A_matrix_type& A() {return this->_state_space.A();}
            B_matrix_type& B() {return this->_state_space.B();}
            C_matrix_type& C() {return this->_state_space.C();}
            D_matrix_type& D() {return this->_state_space.D();}
 
            const A_matrix_type& A() const {return this->_state_space.A();}
            const B_matrix_type& B() const {return this->_state_space.B();}
            const C_matrix_type& C() const {return this->_state_space.C();}
            const D_matrix_type& D() const {return this->_state_space.D();}
 
            friend std::ostream& operator<<(std::ostream& stream, const ContinuousStateSpace& css){
                stream << css.state_space();
                return stream;
            }
    };
 
    template<class T, int NumOrder, int DenOrder>
    ContinuousStateSpace<T, DenOrder, 1, 1> to_continuous_state_space(const TransferFunction<T, NumOrder, DenOrder>& rp){
        return ContinuousStateSpace<T, DenOrder, 1, 1>(to_state_space(rp));
    }
 
    template<class T, int NumOrder, int DenOrder>
    ContinuousStateSpace<T, DenOrder, 1, 1> to_continuous_state_space(const ContinuousTransferFunction<T, NumOrder, DenOrder>& ctf){
        return ContinuousStateSpace<T, DenOrder, 1, 1>(to_state_space(ctf.transfer_function()));
    }
 
    template<class T, int NumOrder, int DenOrder>
    ContinuousStateSpace<T, DenOrder, 1, 1> to_state_space(const ContinuousTransferFunction<T, NumOrder, DenOrder>& ctf){
        return ContinuousStateSpace<T, DenOrder, 1, 1>(to_state_space(ctf.transfer_function()));
    }
 
    template<class T, int states>
    ContinuousTransferFunction<T, states+1, states+1> to_transfer_function(const ContinuousStateSpace<T, states, 1, 1>& dss){
        return ContinuousTransferFunction<T, states+1, states+1>(to_transfer_function(dss.state_space()));
    }
    
} // namespace controlpp