ReSCue - Retrieval System for Curves

---

         

---

angle.h

#ifndef INCLUDE_UNITCIRCLEANGLE
#define INCLUDE_UNITCIRCLEANGLE

#include "rescuenumerics.h"
#include <math.h>

namespace rescue
{

template<class arithmetic>
class unit_circle_angle
{
//private:
public:
    arithmetic s;
    arithmetic c;
    enum {regular,two_pi} type;

public:

    unit_circle_angle<arithmetic>() 
    {
        s = 0.0;
        c = 1.0;
        type = regular;
    }

    unit_circle_angle<arithmetic>(const unit_circle_angle<arithmetic>& uca) 
    {
        s = uca.s;
        c = uca.c;
        type = uca.type;
    }

    unit_circle_angle<arithmetic>(bool angle_two_pi) 
    {
        s = 0.0;
        c = 1.0;
        if (angle_two_pi)
            type = two_pi;
        else
            type = regular;
    }

    arithmetic sin() const
    {
        return s;
    }

    arithmetic cos() const
    {
        return c;
    }

    void bisect()
    {
        arithmetic s_new = sqrt((1-c)/2.0);
        arithmetic c_new = sqrt((1+c)/2.0); 
        int q = quadrant();
        switch (q) {
            case 0:
                s = s_new;
                c = c_new;
                break;
            case 1:
                s = s_new;
                c = c_new;
                break;
            case 2:
                s = s_new;
                c = -c_new;
                break;
            case 3:
                s = s_new;
                c = -c_new;
                break;
        }

        
    }

    inline bool operator==(const unit_circle_angle<arithmetic>& B) const
    {
        return (type==B.type &&  s==B.s && c==B.c);
    }
        
    inline unit_circle_angle<arithmetic>& operator=(const unit_circle_angle<arithmetic>& uca)
    {
        type = uca.type;
        c = uca.c;
        s = uca.s;
        return *this;
    }
        
    inline int quadrant() const
    {
        if (type==two_pi)
            return 3;
        // How nice: sign() is numerically exact and supported by LEDA/real !
        // Not so nice: for double there is no sign()-function by default.
        // That's why it is implemented in rescuenumerics.h / .cpp .
        if (sign(s)==0)
            if (sign(c)>=0)
                return 0;
            else
                return 2;
        else if (sign(s)>0)
            if (sign(c)==1)
                return 0;
            else
                return 1;
        else // sign(s)<0
            if (sign(c)<0)
                return 2;
            else
                return 3;
    }


    inline unit_circle_angle<arithmetic>& operator-=(const unit_circle_angle<arithmetic>& B)
    {

        // by definition, the resulting interval is regular
        type = regular;

        // use addition theorems for sin and cos:
        // cos(a-b) = cos(a)cos(b) + sin(a)sin(b)
        // sin(a-b) = sin(a)cos(b) - cos(a)sin(b)
        arithmetic c2 = c*B.c + s*B.s;
        arithmetic s2 = s*B.c - c*B.s;
        c = c2;
        s = s2;
        return *this;
        
    }

    inline unit_circle_angle<arithmetic>& operator+=(const unit_circle_angle<arithmetic>& B)
    {
        
        // by definition, the resulting interval is regular
        type = regular;        

        // use subtraction theorems for sin and cos:
        // cos(a+b) = cos(a)cos(b) - sin(a)sin(b)
        // sin(a+b) = sin(a)cos(b) + cos(a)sin(b)
        arithmetic c2 = c*B.c - s*B.s;
        arithmetic s2 = s*B.c + c*B.s;
        c = c2;
        s = s2;
        return *this;

    }

    inline unit_circle_angle<arithmetic> operator+(const unit_circle_angle<arithmetic>& B) const
    {
        unit_circle_angle<arithmetic> A;
        A = *this;
        A += B;
        return A;
    }
    
    inline unit_circle_angle<arithmetic> operator-(const unit_circle_angle<arithmetic>& B) const
    {
        unit_circle_angle<arithmetic> A;
        A = *this;
        A -= B;
        return A;
    }
    
    inline unit_circle_angle<arithmetic>(const arithmetic& sin1, const arithmetic& cos1)
    {
        type = regular;
        /*if (s>1.0)
        {
            s=1.0;
            c=0.0;
            return;
        }
        if (s<-1.0)
        {
            s=-1.0;
            c=0.0;
            return;
        }
        if (c>1.0)
        {
            s=0.0;
            c=1.0;
            return;
        }
        if (c<-1.0)
        {
            s=0.0;
            c=-1.0;
            return;
        }*/
        s = sin1;
        c = cos1;
    }

    inline bool operator<(const unit_circle_angle<arithmetic>& A) const
    {
        int q = quadrant();
        int qa = A.quadrant();
        if (q<qa)
            return true;
        if (q>qa)
            return false;
        
        // q==qa
        switch(q)
        {
        case 0:
            return s<A.s;
        case 1:
            return s>A.s;
        case 2:
            return s>A.s;
        case 3:
            return s<A.s;

        }
        return false;
    }

    inline bool operator<=(const unit_circle_angle<arithmetic>& A) const
    {
        return (*this)<A || (*this)==A;
    }

    inline bool between(const unit_circle_angle<arithmetic>& lower, const unit_circle_angle<arithmetic>& upper) const
    {
        if (lower<upper)
            // circular arc between lower und upper does not cover angle 0
            return lower<*this && *this<upper;
        else
            // circular arc between lower und upper covers angle 0
            return lower<*this || *this<upper;
    }

#ifndef RESCUE__IGNORE_RAD
    double rad() const
    {
        double x = atan(s/c);
        int q = quadrant();
        switch(q)
        {
            case 0:
                return x;
            case 1:
                return x+PI;
            case 2:
                return x+PI;
            case 3:
                return x+2.0*PI;
        }       
        return x;
    }
#endif

};

}

#endif

ReSCue - Retrieval System for Curves
Universität Bonn, Institut für Informatik III, 2001