Add quadtree back to the Makefile
[ipdf/code.git] / src / vfpu.h
index 8444afd..cb7fe50 100644 (file)
@@ -1,6 +1,7 @@
 /**
  * @file vfpu.h
  * @brief Implements a terrible and hacky interface to use a virtual FPU to do floating point operations
 /**
  * @file vfpu.h
  * @brief Implements a terrible and hacky interface to use a virtual FPU to do floating point operations
+ *     Updated with even more terror! Whatever floats the boat!
  */
 
 #ifndef _VFPU_H
  */
 
 #ifndef _VFPU_H
@@ -17,71 +18,74 @@ namespace VFPU
        extern Register Exec(const Register & a, const Register & b, Opcode op, Rmode rmode = EVEN); // operate with registers
        extern float Exec(float a, float b, Opcode op, Rmode rmode = EVEN); //converts floats into registers and back
        
        extern Register Exec(const Register & a, const Register & b, Opcode op, Rmode rmode = EVEN); // operate with registers
        extern float Exec(float a, float b, Opcode op, Rmode rmode = EVEN); //converts floats into registers and back
        
-       class Float
+       /**
+        * Wrapper class for floats where operations are done on the VFPU
+        */
+       class VFloat
        {
                public:
        {
                public:
-                       Float(float f = 0) : m_value(f) 
+                       VFloat(float f = 0) : m_value(f) 
                        {
                                static bool init = false;
                                if (!init)
                                {
                                        init = true;
                        {
                                static bool init = false;
                                if (!init)
                                {
                                        init = true;
-                                       VFPU::Start();
+                                       VFPU::Start("flops.vcd");
                                }
                        }
                                }
                        }
-                       Float(const Float & cpy) : m_value(cpy.m_value) {}
-                       virtual ~Float() 
+                       VFloat(const VFloat & cpy) : m_value(cpy.m_value) {}
+                       virtual ~VFloat() 
                        {
 
                        }
                        
                        {
 
                        }
                        
-                       Float & operator+=(const Float & op)
+                       VFloat & operator+=(const VFloat & op)
                        {
                                m_value = Exec(m_value, op.m_value, ADD);
                                return *this;
                        }
                        {
                                m_value = Exec(m_value, op.m_value, ADD);
                                return *this;
                        }
-                       Float & operator-=(const Float & op)
+                       VFloat & operator-=(const VFloat & op)
                        {
                                m_value = Exec(m_value, op.m_value, SUB);
                                return *this;
                        }
                        {
                                m_value = Exec(m_value, op.m_value, SUB);
                                return *this;
                        }
-                       Float & operator*=(const Float & op)
+                       VFloat & operator*=(const VFloat & op)
                        {
                                m_value = Exec(m_value, op.m_value, MULT);
                                return *this;
                        }
                        {
                                m_value = Exec(m_value, op.m_value, MULT);
                                return *this;
                        }
-                       Float & operator/=(const Float & op)
+                       VFloat & operator/=(const VFloat & op)
                        {
                                m_value = Exec(m_value, op.m_value, DIV);
                                return *this;
                        }
                        
                        {
                                m_value = Exec(m_value, op.m_value, DIV);
                                return *this;
                        }
                        
-                       Float operator+(const Float & op) const {Float f(*this); f+=op; return f;}
-                       Float operator-(const Float & op) const {Float f(*this); f-=op; return f;}
-                       Float operator*(const Float & op) const {Float f(*this); f*=op; return f;}
-                       Float operator/(const Float & op) const {Float f(*this); f/=op; return f;}
+                       VFloat operator+(const VFloat & op) const {VFloat f(*this); f+=op; return f;}
+                       VFloat operator-(const VFloat & op) const {VFloat f(*this); f-=op; return f;}
+                       VFloat operator*(const VFloat & op) const {VFloat f(*this); f*=op; return f;}
+                       VFloat operator/(const VFloat & op) const {VFloat f(*this); f/=op; return f;}
                        
                        
-                       bool operator==(const Float & op) const
+                       bool operator==(const VFloat & op) const
                        {
                        {
-                               Float f(op);
+                               VFloat f(op);
                                f -= *this;
                                return (f.m_value == 0);                                
                        }
                                f -= *this;
                                return (f.m_value == 0);                                
                        }
-                       bool operator!=(const Float & op) const {return !this->operator==(op);}
-                       bool operator<(const Float & op) const
+                       bool operator!=(const VFloat & op) const {return !this->operator==(op);}
+                       bool operator<(const VFloat & op) const
                        {
                        {
-                               Float f(op);
+                               VFloat f(op);
                                f -= *this;
                                return (f.m_value > 0);
                        }
                                f -= *this;
                                return (f.m_value > 0);
                        }
-                       bool operator<=(const Float & op) const
+                       bool operator<=(const VFloat & op) const
                        {
                        {
-                               Float f(op);
+                               VFloat f(op);
                                f -= *this;
                                return (f.m_value >= 0);                                
                        }
                                f -= *this;
                                return (f.m_value >= 0);                                
                        }
-                       bool operator>(const Float & op) const {return !this->operator<=(op);}
-                       bool operator>=(const Float & op) const {return !this->operator<(op);}
+                       bool operator>(const VFloat & op) const {return !this->operator<=(op);}
+                       bool operator>=(const VFloat & op) const {return !this->operator<(op);}
                        
                        float m_value;
                        
                        
                        float m_value;
                        

UCC git Repository :: git.ucc.asn.au