evAddress.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 __evAddress_h
#define __evAddress_h


#include "evDataObject.h"

#include <vector>
#include <iostream>
#include <iterator>
#include <numeric>
#include <cstdlib>
#include <cmath>

class evAddress : public evDataObject
{
 public:
  evAddress(void);
  evAddress(const unsigned int num_dimensions);
  evAddress(const evAddress &address);
  virtual ~evAddress(void)
    { }
  
  virtual const evString GetClassName(void) const
    {
      return(evString("evAddress"));
    }
  
  void Set(const int value,
           const unsigned int dimension);

  int *Get(void);
  int Get(const unsigned int dimension) const;
  int &operator [] (const unsigned int index);
  const int &operator [] (const unsigned int index) const;

  unsigned int GetNumDimensions(void) const;

  evAddress operator = (const evAddress &address);
  evAddress operator = (const int value);
  bool operator == (const evAddress &address) const;
  bool operator != (const evAddress &address) const;
  bool operator < (const evAddress &address) const;

  evAddress operator + (const evAddress &address) const;
  evAddress operator + (const int value) const;
  evAddress operator - (const evAddress &address) const;
  evAddress operator - (const int value) const;
  evAddress &operator += (const evAddress &address);
  evAddress &operator -= (const evAddress &address);

  evAddress operator % (const int value) const;

  void SetIncrementStep(const int increment_step);
  int GetIncrementStep(void) const;

  void Increment(const unsigned int dimension);
  int Increment(const evAddress &max_address);
  int Increment(const evAddress &max_address,
                const unsigned int fixed_dimension);

  int Sum(void) const;
  int Product(void) const;
  
  void Clip(const evAddress *lower_bound,
            const evAddress *upper_bound);

  virtual void PrintSelf(const int tabbing) const;

 protected:
  
 private:
  std::vector<int> Address;
  int IncrementStep;
};


inline evAddress::evAddress(void) :
  IncrementStep(1)
{ }


inline evAddress::evAddress(const unsigned int num_dimensions) :
  Address(num_dimensions, 0),
  IncrementStep(1)
{ }


inline evAddress::evAddress(const evAddress &address) :
  Address(address.Address),
  IncrementStep(1)
{ }


inline void evAddress::Set(const int value,
                           const unsigned int dimension)
{
  this->Address[dimension] = value;
}


inline int *evAddress::Get(void)
{
  return(&(this->Address.front()));
}


inline int evAddress::Get(const unsigned int dimension) const
{
  return(this->Address[dimension]);
}


inline int &evAddress::operator [] (const unsigned int index)
{
  return(this->Address[index]);
}


inline const int &evAddress::operator [] (const unsigned int index) const
{
  return(this->Address[index]);
}


inline unsigned int evAddress::GetNumDimensions(void) const
{
  return(this->Address.size());
}


inline evAddress evAddress::operator = (const evAddress &address)
{
  this->Address = address.Address;
  return(*this);
}


inline evAddress evAddress::operator = (const int value)
{
  std::fill(this->Address.begin(),
            this->Address.end(),
            value);

  return(*this);
}


inline bool evAddress::operator == (const evAddress &address) const
{
  return(this->Address == address.Address);
}


inline bool evAddress::operator != (const evAddress &address) const
{
  return(!((*this) == address));
}


inline bool evAddress::operator < (const evAddress &address) const
{
  unsigned int dimension;
  
  for (dimension = 0; dimension < this->GetNumDimensions(); dimension++)
    if (this->Get(dimension) > address.Get(dimension))
      return(0);
    else
      if (this->Get(dimension) < address.Get(dimension))
        return(1);

  return(0);
}


inline void evAddress::SetIncrementStep(const int increment_step)
{
  this->IncrementStep = increment_step;
}


inline int evAddress::GetIncrementStep(void) const
{
  return(this->IncrementStep);
}


inline void evAddress::Increment(const unsigned int dimension)
{
  this->Address[dimension] += this->IncrementStep;
}


inline int evAddress::Increment(const evAddress &max_address)
{
  unsigned int dimension;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    {
      this->Address[dimension] += this->IncrementStep;
      if (this->Address[dimension] < max_address.Get(dimension))
        return(0);
      this->Address[dimension] = 0;
    }
  
  return(1);
}


inline int evAddress::Increment(const evAddress &max_address,
                                const unsigned int fixed_dimension)
{
  unsigned int dimension;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    if (dimension != fixed_dimension)
      {
        this->Address[dimension] += this->IncrementStep;
        if (this->Address[dimension] < max_address.Get(dimension))
          return(0);
        this->Address[dimension] = 0;
      }
  
  return(1);
}


inline int evAddress::Sum(void) const
{
  return(std::accumulate(this->Address.begin(), this->Address.end(), 0));
}


inline int evAddress::Product(void) const
{
  return(std::accumulate(this->Address.begin(), this->Address.end(), 1,
                         std::multiplies<int>()));
}


inline void evAddress::Clip(const evAddress *lower_bound,
                            const evAddress *upper_bound)
{
  for (unsigned int dimension = 0;
       dimension < this->Address.size(); dimension++)
    {
      int value = this->Get(dimension);
      if (lower_bound)
        value = QccMathMax(value,
                           lower_bound->Get(dimension));

      if (upper_bound)
        value = QccMathMin(value,
                           upper_bound->Get(dimension));

      this->Set(value, dimension);
    }
}


inline evAddress evAddress::operator + (const evAddress &address) const
{
  unsigned int dimension;
  
  if (this->Address.size() != address.Address.size())
    {
      evAddress result;
      return(result);
    }

  evAddress result = *this;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    result.Address[dimension] += address.Address[dimension];
  
  return(result);
}


inline evAddress evAddress::operator + (const int value) const
{
  unsigned int dimension;
  
  evAddress result = *this;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    result.Address[dimension] += value;
  
  return(result);
}


inline evAddress evAddress::operator - (const evAddress &address) const
{
  unsigned int dimension;
  
  if (this->Address.size() != address.Address.size())
    {
      evAddress result;
      return(result);
    }

  evAddress result = *this;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    result.Address[dimension] -= address.Address[dimension];
  
  return(result);
}


inline evAddress evAddress::operator - (const int value) const
{
  unsigned int dimension;
  
  evAddress result = *this;
  
  for (dimension = 0; dimension < this->Address.size(); dimension++)
    result.Address[dimension] -= value;
  
  return(result);
}


inline evAddress &evAddress::operator += (const evAddress &address)
{
  unsigned int dimension;
  
  if (this->Address.size() != address.Address.size())
    this->Address = std::vector<int>();
  else
    for (dimension = 0; dimension < this->Address.size(); dimension++)
      this->Address[dimension] += address.Address[dimension];

  return(*this);
}


inline evAddress &evAddress::operator -= (const evAddress &address)
{
  unsigned int dimension;
  

  if (this->Address.size() != address.Address.size())
    this->Address = std::vector<int>();
  else
    for (dimension = 0; dimension < this->Address.size(); dimension++)
      this->Address[dimension] -= address.Address[dimension];

  return(*this);
}


inline evAddress evAddress::operator % (const int value) const
{
  evAddress result(this->Address.size());
  
  for (unsigned int dimension = 0;
       dimension < this->Address.size(); dimension++)
    result.Address[dimension] = this->Address[dimension] % value;
  
  return(result);
}


#endif