Types.h

 
#pragma once
 
#include "Common.h"
#include "MathSupplement.h"
 
namespace Iir
{

struct IIR_EXPORT ComplexPair : complex_pair_t
{
    ComplexPair () = default;
 
    static constexpr double epsilon = 1E-10;
 
    explicit ComplexPair (const complex_t &c1) : complex_pair_t (c1, complex_t(0))
    {
        if (!isReal ())
            throw_invalid_argument (
                "A single complex number needs to be real.");
    }
 
    ComplexPair (const complex_t &c1, const complex_t &c2)
        : complex_pair_t (c1, c2)
    {
    }
 
    bool isReal () const
    {
        return (std::abs (first.imag ()) < epsilon)
               && (std::abs (second.imag ()) < epsilon);
    }

    bool isMatchedPair () const
    {
        if ((isReal () && (std::abs (first.real ()) > epsilon))
            && (std::abs (second.real ()) > epsilon))
            return true;
        return std::abs(second - std::conj (first)) < epsilon;
    }
 
    bool is_nan () const
    {
        return Iir::is_nan (first) || Iir::is_nan (second);
    }
};

struct IIR_EXPORT PoleZeroPair
{
    ComplexPair poles = ComplexPair ();
    ComplexPair zeros = ComplexPair ();
 
    PoleZeroPair () = default;
 
    static constexpr double epsilon = 1E-10;
 
    // single pole/zero
    PoleZeroPair (const complex_t &p, const complex_t &z)
        : poles (p), zeros (z)
    {
    }
 
    // pole/zero pair
    PoleZeroPair (const complex_t &p1, const complex_t &z1,
                  const complex_t &p2, const complex_t &z2)
        : poles (p1, p2), zeros (z1, z2)
    {
    }
 
    bool isSinglePole () const
    {
        return (std::abs(poles.second) < epsilon) && (std::abs(zeros.second) < epsilon);
    }
 
    bool is_nan () const { return poles.is_nan () || zeros.is_nan (); }
};
 
}