evVector.h

Go to the documentation of this file.

/*
 *
 * EVITA: Efficient Visualization of Terascale Datasets
 * Copyright (C) 2000-2016  Team Evita
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 *
 */


#ifndef __evVector_h
#define __evVector_h


#include "evAddress.h"

#include <numeric>
#include <algorithm>
#include <vector>
#include <iostream>


class evVector : public evDataObject
{
public:
  evVector(void);
  evVector(const unsigned int num_dimensions);
  evVector(const QccVector vector, const unsigned int num_dimensions);
  evVector(const evVector &vector);
  evVector(const evVector &vector, unsigned int num_dimensions);
  evVector(const evAddress &address);

  virtual ~evVector(void);

  virtual const evString GetClassName(void) const
    {
      return(evString("evVector"));
    }

  void SetDimension(const unsigned int dimension);

  unsigned int Dimension(void) const;
  bool IsNull(void) const;

  double &operator [] (const unsigned int index);
  const double &operator [] (const unsigned int index) const;

  evVector operator = (const evVector &vector);
  evVector operator = (const double value);
  evVector operator + (const evVector &vector) const;
  evVector operator - (void) const;
  evVector operator - (const evVector &vector) const;
  evVector &operator += (const evVector &vector);
  evVector &operator -= (const evVector &vector);
  double operator * (const evVector &vector) const;
  evVector &operator *= (const double scalar);
  evVector &operator /= (const double scalar);

  bool operator == (const evVector &vector) const;
  bool operator != (const evVector &vector) const;

  operator double() const;

  double Norm(void) const;
  double Angle(void) const;
  double Max(void) const;
  void Max(const evVector &vector1, const evVector &vector2);
  double Min(void) const;
  void Min(const evVector &vector1, const evVector &vector2);

  virtual void PrintSelf(const int tabbing) const;

protected:

private:
  std::vector<double> Vector;
};


inline evVector::evVector(void)
{ }


inline evVector::evVector(const unsigned int num_dimensions) :
  Vector(num_dimensions, 0.0)
{ }


inline evVector::evVector(const QccVector vector,
                          const unsigned int num_dimensions)
{
  unsigned int index;

  this->Vector = std::vector<double>();
  for (index = 0; index < num_dimensions; index++)
    this->Vector.push_back(vector[index]);
}


inline evVector::evVector(const evVector &vector) :
  Vector(vector.Vector)
{ }


inline evVector::evVector(const evVector &vector,
                          const unsigned int num_dimensions)
{
  this->Vector = std::vector<double>();
  for (unsigned int index = 0;
       index < std::min(num_dimensions, (unsigned int)vector.Vector.size());
       index++)
    this->Vector.push_back(vector[index]);
}


inline evVector::evVector(const evAddress &address)
{
  this->Vector.resize(address.GetNumDimensions());
  for (unsigned int component = 0; component < this->Vector.size();
       component++)
    this->Vector[component] = (double)address.Get(component);
}


inline evVector::~evVector(void)
{ }


inline void evVector::SetDimension(const unsigned int dimension)
{
  double value = 0;
  this->Vector.resize(dimension, value);
}


inline unsigned int evVector::Dimension(void) const
{
  return(this->Vector.size());
}


inline bool evVector::IsNull(void) const
{
  return(this->Vector.empty());
}


inline double &evVector::operator [] (const unsigned int index)
{
  return(this->Vector[index]);
}


inline const double &evVector::operator [] (const unsigned int index) const
{
  return(this->Vector[index]);
}


inline evVector evVector::operator = (const evVector &vector)
{
  this->Vector = vector.Vector;

  return(*this);
}


inline evVector evVector::operator = (const double value)
{
  std::fill(this->Vector.begin(),
            this->Vector.end(),
            value);
  return(*this);
}


inline evVector evVector::operator + (const evVector &vector) const
{
  unsigned int index;

  if (this->Vector.size() != vector.Vector.size())
    {
      evVector result;
      return(result);
    }

  evVector result = *this;

  for (index = 0;
       index < result.Vector.size();
       index++)
    result.Vector[index] += vector.Vector[index];

  return(result);
}


inline evVector evVector::operator - (void) const
{
  unsigned int index;

  evVector result = *this;

  for (index = 0;
       index < result.Vector.size();
       index++)
    result.Vector[index] = - result.Vector[index];

  return(result);
}


inline evVector evVector::operator - (const evVector &vector) const
{
  unsigned int index;

  if (this->Vector.size() != vector.Vector.size())
    {
      evVector result;
      return(result);
    }

  evVector result = *this;

  for (index = 0;
       index < result.Vector.size();
       index++)
    result.Vector[index] -= vector.Vector[index];

  return(result);
}


inline evVector &evVector::operator += (const evVector &vector)
{
  unsigned int index;

  if (this->Vector.size() != vector.Vector.size())
    this->Vector = std::vector<double>();

  else
    for (index = 0;
         index < this->Vector.size();
         index++)
      this->Vector[index] += vector.Vector[index];

  return(*this);
}


inline evVector &evVector::operator -= (const evVector &vector)
{
  unsigned int index;

  if (this->Vector.size() != vector.Vector.size())
    this->Vector = std::vector<double>();

  else
    for (index = 0;
         index < this->Vector.size();
         index++)
      this->Vector[index] -= vector.Vector[index];
  
  return(*this);
}


static inline double NaN(void)
{
  union
    {
      double x1;
      unsigned char x2[sizeof(double)];
    } x;

  unsigned int i;
  for (i = 0; i < sizeof(double); i++)
    x.x2[i] = 0xff;

  return(x.x1);
}


inline double evVector::operator * (const evVector &vector) const
{
  if (this->Vector.size() != vector.Vector.size())
    return(NaN());

  return(std::inner_product(this->Vector.begin(),
                            this->Vector.end(),
                            vector.Vector.begin(),
                            (double)0));
}


inline evVector operator * (const double scalar, const evVector &vector)
{
  unsigned int index;

  evVector result = vector;

  for (index = 0; index < vector.Dimension(); index++)
    result[index] *= scalar;

  return(result);
}


inline evVector operator * (const evVector &vector, const double scalar)
{
  unsigned int index;

  evVector result = vector;

  for (index = 0; index < vector.Dimension(); index++)
    result[index] *= scalar;

  return(result);
}


inline evVector &evVector::operator *= (const double scalar)
{
  unsigned int index;

  for (index = 0;
       index < this->Vector.size();
       index++)
    this->Vector[index] *= scalar;

  return(*this);
}


inline evVector operator / (const evVector &vector, const double scalar)
{
  unsigned int index;

  evVector result = vector;

  for (index = 0; index < vector.Dimension(); index++)
    result[index] /= scalar;

  return(result);
}


inline evVector &evVector::operator /= (const double scalar)
{
  unsigned int index;

  for (index = 0;
       index < this->Vector.size();
       index++)
    this->Vector[index] /= scalar;

  return(*this);
}


inline bool evVector::operator == (const evVector &vector) const
{
  return(this->Vector == vector.Vector);
}


inline bool evVector::operator != (const evVector &vector) const
{
  return(this->Vector != vector.Vector);
}


inline evVector::operator double() const
{
  if (this->Vector.size() == 1)
    return(this->Vector[0]);
  else
    return(0);
}


inline double evVector::Norm(void) const
{
  return(sqrt((*this) * (*this)));
}


inline double evVector::Angle(void) const
{
  if (this->Dimension() != 2)
    return(0);
  else
    return(atan2((*this)[1], (*this)[0]) + M_PI);
}


inline double evVector::Max(void) const
{
  if (this->Vector.empty())
    return(NaN());

  double max = *std::max_element(this->Vector.begin(),
                                 this->Vector.end());

  return(max);
}


inline void evVector::Max(const evVector &vector1, const evVector &vector2)
{
  if (vector1.Vector.size() != vector2.Vector.size())
    return;

  this->Vector.resize(vector1.Vector.size());

  for (unsigned int component = 0;
       component < this->Vector.size();
       component++)
    (*this)[component] = std::max(vector1[component],
                                  vector2[component]);
}


inline double evVector::Min(void) const
{
  if (this->Vector.empty())
    return(NaN());

  double min = *std::min_element(this->Vector.begin(),
                                 this->Vector.end());

  return(min);
}


inline void evVector::Min(const evVector &vector1, const evVector &vector2)
{
  if (vector1.Vector.size() != vector2.Vector.size())
    return;

  this->Vector.resize(vector1.Vector.size());

  for (unsigned int component = 0;
       component < this->Vector.size();
       component++)
    (*this)[component] = std::min(vector1[component],
                                  vector2[component]);
}


inline std::ostream &operator << (std::ostream &outfile,
                                  const evVector &vector)
{
  outfile << "< ";

  if (vector.IsNull())
    outfile << "NULL ";
  else
    {
      unsigned int index;
      for (index = 0; index < vector.Dimension(); index++)
        outfile << vector[index] << " ";
    }

  outfile << ">";

  return(outfile);
}


#endif