conversion.hpp

Go to the documentation of this file.

#pragma once
 
#include <numbers>
#include <cmath>
#include <Eigen/Dense>
 
namespace controlpp{
 
    template<class T>
    T to_hz(const T& radps){
        constexpr T factor = std::numbers::inv_pi_v<T> / 2;
        return radps * factor;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> to_hz(const Eigen::Vector<T, N>& radps){
        constexpr T factor = std::numbers::inv_pi_v<T> / 2;
        return radps * factor;
    }
 
    template<class T>
    T to_radps(const T& hz){
        constexpr T factor = 2 * std::numbers::pi_v<T>;
        return hz * factor;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> to_radps(const Eigen::Vector<T, N>& hz){
        constexpr T factor = 2 * std::numbers::pi_v<T>;
        return hz * factor;
    }
 
    template<class T>
    T to_deg(const T& rad){
        constexpr T factor = static_cast<T>(180) / std::numbers::pi_v<T>;
        return rad * factor;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> to_deg(const Eigen::Vector<T, N>& rad){
        constexpr T factor = static_cast<T>(180) / std::numbers::pi_v<T>;
        return rad * factor;
    }
 
    template<class T>
    T to_rad(const T& deg){
        constexpr T factor = std::numbers::pi_v<T> / static_cast<T>(180);
        return deg * factor;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> to_rad(const Eigen::Vector<T, N>& deg){
        constexpr T factor = std::numbers::pi_v<T> / static_cast<T>(180);
        return deg * factor;
    }
 
    template<class T>
    T to_dB(const T& value){
        return 20 * std::log10(value);
    }
 
    template<class T>
    T from_dB(const T& value){
        return std::pow(static_cast<T>(10), value / static_cast<T>(20));
    }
 
    template<class T>
    T prewarp_tustin(const T& omega, const T& Ts){
        const T result = (static_cast<T>(2) / Ts) * std::tan(omega * Ts / static_cast<T>(2));
        return result;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> prewarp_tustin(const Eigen::Vector<T, N>& omegas, const T& Ts){
        const Eigen::Vector<T, N> result = ((static_cast<T>(2) / Ts) * (omegas.array() * Ts / static_cast<T>(2)).tan()).matrix();
        return result;
    }
 
    template<class T>
    T unwarp_tustin(const T& omega, const T& Ts){
        const T result = (static_cast<T>(2) / Ts) * std::atan(omega * Ts / static_cast<T>(2));
        return result;
    }
 
    template<class T, int N>
    Eigen::Vector<T, N> unwarp_tustin(const Eigen::Vector<T, N>& omegas, const T& Ts){
        const Eigen::Vector<T, N> result = ((static_cast<T>(2) / Ts) * (omegas.array() * Ts / static_cast<T>(2)).atan()).matrix();
        return result;
    }
 
}