/home/sagar/ms/thesis/sarathi/src/libhyperpoint/libhyperpoint.cpp

Go to the documentation of this file.

#include <iostream>
#include <ostream>
//soapH.h needs to be included here else libsarathi segfaults when serializing data (Yes, it does!)
//soapH.h includes soapStub.h which contains the same headers as libhyperpoint.h (they came there from soapcpp2 -i soapservices.hpp)
//Hence, if both libhyperpoint.hpp and soapH.h are included, we get multiple declaration errors
//Including soapH.h pulls in some other function declarations because of which: 
//1) this library needs gsoap/soapC.cpp in the list of source files during compilation
//2) unless libgsoap++ and libsarathi are linked with the application which uses libhyperpoint, the application won't compile
// This SUCKS. But I can't find a way around it right now :(
#include "../gsoap/soapH.h"
//#else
//#include "libhyperpoint.hpp"
//#endif
#include <string>
#include <sstream>

//namespace libhyperpoint {

hyperpoint::hyperpoint ()
{
        __ptr = NULL;
        __size = 0;
}

hyperpoint::hyperpoint (const hyperpoint & point)
{
        __size = point.__size;
        __ptr = new float[__size];
        for (int i = 0; i < __size; i++)
                __ptr[i] = point.__ptr[i];
}

hyperpoint::hyperpoint (int size)
{
        __ptr = new float[size];
        __size = size;
        for (int i = 0; i < __size; i++)
                __ptr[i] = -1.0;
}

hyperpoint::~hyperpoint ()
{
        if (__ptr == NULL && __size == 0)       //hyperpoint has already been reset or empty constructor called and point was never used
                return;
        if (__size > 1)
                delete [] __ptr;
        else if (__size == 1)
                delete __ptr;
        __ptr = NULL;
        __size = 0;
}

int
hyperpoint::size () const
{
        return __size;
}

float &
hyperpoint::operator[] (int i) const
{
        return __ptr[i];
}

float
hyperpoint::operator  () (int i) const
{
        if (i >= 0 && i < __size)
                return __ptr[i];
        return -1.0;            //since we will use normalized joint values [0,1], -1 is an invalid value
}

hyperpoint & hyperpoint::operator= (const hyperpoint & point)
{
        if (__size > 0)         // if an existing hyperpoint is being redefined, reset it first
                this->reset ();
        __size = point.__size;
        __ptr = new float[__size];
        for (int i = 0; i < __size; i++)
                __ptr[i] = point.__ptr[i];
        return *this;
}

void
hyperpoint::print () const
{
        std::cout << std::endl << "Printing point of size " << this->__size << ":" << std::endl;
        for (int i = 0; i < __size; i++)
          {
                  std::cout << "joint[" << i << "] = " << __ptr[i] << std::endl;
          }
        std::cout << std::endl;
        return;
}

void
hyperpoint::print (std::ostream &printstream) const
{
        printstream << std::endl << "Printing point of size " << this->__size << ":" << std::endl;
        for (int i = 0; i < __size; i++)
          {
                  printstream << "joint[" << i << "] = " << __ptr[i] << std::endl;
          }
        printstream << std::endl;
        return;
}

void
hyperpoint::initialize (int size)
{
        if (__ptr == NULL)
          {                     //we initialize only if hyperpoint was created with empty constructor
                  __ptr = new float[size];
                  __size = size;
                  for (int i = 0; i < __size; i++)
                          __ptr[i] = -1.0;
          }
}

void
hyperpoint::reset ()
{
        if (__size < 0)
                delete __ptr;
        else
                delete[]__ptr;
        __ptr = NULL;
        __size = 0;
}

double hyperpoint::norm2() const
{
        double sum = 0;
        for (int i = 0; i < __size; i++){
                double val = (*this)[i];
                sum += val*val;
        }
        return sum;
}

// double hyperpoint::operator - (const hyperpoint &y) const
// {//TODO: ensure that y argument is same size as (*this)
//      double sum = 0;
//      for (int i = 0; i < __size; i++){
//              double diff = (*this)[i] - y[i];
//              sum += diff*diff;
//      }
//      return sqrt(sum);
// }

hyperpoint hyperpoint::operator - (const hyperpoint &y) const
{
        hyperpoint difference(__size);
        //change value of difference
        for (int i = 0; i < __size; i++){
                difference[i] = (*this)[i]-y[i];
        }
        return difference;
}

bool hyperpoint::operator < (double threshold) const
{
        for (int i = 0; i < __size; i++){
                if (fabs((*this)(i)) > threshold){
                        std::cout << "OPERATOR < RETURNING FALSE BECAUSE " << (*this)(i) << " > " << threshold;
                        return false;
                }
        }
        return true;
}

double hyperpoint::dist2(const hyperpoint &y) const
{//TODO: ensure that y argument is same size as (*this)
        double sum = 0;
        for (int i = 0; i < __size; i++){
                double diff = (*this)[i] - y[i];
                sum += diff*diff;
        }
        return sum;
}

hyperarray::hyperarray ()
{
        __ptr = NULL;
        __size = 0;
}

hyperarray::hyperarray (int size)
{
        __ptr = new hyperpoint[size];
        __size = size;
}

hyperarray::hyperarray (const hyperarray & array)
{
        __size = array.__size;
        __ptr = new hyperpoint[__size];
        for (int i = 0; i < __size; i++)
                __ptr[i] = array.__ptr[i];
}

hyperarray::~hyperarray ()
{
        if (__ptr == NULL && __size == 0)       //hyperarray has already been reset or empty constructor called and array was never used
                return;
        if (__size < 0)
                delete __ptr;
        else
                delete[]__ptr;
}

int
hyperarray::size () const
{
        return __size;
}

hyperpoint & hyperarray::operator[](int i) const
{
        return __ptr[i];
}

hyperpoint hyperarray::operator  ()(int i) const
{                               //TODO: check if i is within bounds and deal with it if it is not
        return __ptr[i];
}

hyperarray & hyperarray::operator= (const hyperarray & array)
{
        if (__size > 0)         //if an existing hyperarray is being redefined
                this->reset ();
        __size = array.__size;
        __ptr = new hyperpoint[__size];
        for (int i = 0; i < __size; i++)
                __ptr[i] = array.__ptr[i];
        return *this;
}

void
hyperarray::initialize (int size)
{
        if (__ptr == NULL)
          {                     //we initialize only if hyperarray was created with empty constructor                                                                   
                  __ptr = new hyperpoint[size];
                  __size = size;
          }
}

void
hyperarray::reset (void)
{
        if (__size > 0)
          {                     //we need to free any memory allocated to member hyperpoints, else we could have dangling pointers
                  for (int i = 0; i < __size; i++)
                    {
                            if (__ptr[i].size () > 0)
                                    __ptr[i].reset ();
                    }
          }
        __ptr = NULL;
        __size = 0;
}

void
hyperarray::print (void) const
{
        std::cout << "Printing hyperarray of size " << this->__size << std::endl;
        for (int i = 0; i < __size; i++)
          {
                  std::cout << "Point " << i << ":" << std::endl;
                  __ptr[i].print ();
          }
        std::cout << std::endl;
        return;
}

void
hyperarray::print (std::ostream &printstream) const
{
        printstream << "Printing hyperarray of size " << this->__size << std::endl;
        for (int i = 0; i < __size; i++)
          {
                  printstream << "Point " << i << ":" << std::endl;
                  __ptr[i].print (printstream);
          }
        printstream << std::endl;
        return;
}
//} // namespace libhyperpoint

---