Types.h

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

        struct IIR_EXPORT ComplexPair : complex_pair_t
        {
                ComplexPair() = default;
 
                explicit ComplexPair (const complex_t& c1)
                        : complex_pair_t (c1, 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 first.imag() == 0 && second.imag() == 0;
                }

                bool isMatchedPair () const
                {
                        if (first.imag() != 0)
                                return second == std::conj (first);
                        else
                                return second.imag () == 0 &&
                                        second.real () != 0 &&
                                        first.real () != 0;
                }
 
                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;
 
                // 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 poles.second == 0. && zeros.second == 0.;
                }
 
                bool is_nan () const
                {
                        return poles.is_nan() || zeros.is_nan();
                }
        };
 
 
}