HyperPoint.cpp

Go to the documentation of this file.

#include "Mint/HyperPoint.h"
#include <math.h>

HyperPoint::HyperPoint(int dimension) :
  _coords(dimension, 0.0)
{
}

HyperPoint::HyperPoint(int dimension, double val) :
  _coords(dimension, val)
{
}

HyperPoint::HyperPoint(std::vector<double> coords) :
  _coords(coords)
{
}

HyperPoint::HyperPoint(double x1) :
  _coords(1, 0.0)
{
  at(0) = x1;
}

HyperPoint::HyperPoint(double x1, double x2) :
  _coords(2, 0.0)
{
  at(0) = x1;
  at(1) = x2;
}

HyperPoint::HyperPoint(double x1, double x2, double x3) :
  _coords(3, 0.0)
{
  at(0) = x1;
  at(1) = x2;
  at(2) = x3;
}

HyperPoint::HyperPoint(double x1, double x2, double x3, double x4) :
  _coords(4, 0.0)
{
  at(0) = x1;
  at(1) = x2;
  at(2) = x3;
  at(3) = x4;
}

HyperPoint::HyperPoint(double x1, double x2, double x3, double x4, double x5) :
  _coords(5, 0.0)
{
  at(0) = x1;
  at(1) = x2;
  at(2) = x3;
  at(3) = x4;
  at(4) = x5;
}

HyperPoint::HyperPoint(double x1, double x2, double x3, double x4, double x5, double x6) :
  _coords(6, 0.0)
{
  at(0) = x1;
  at(1) = x2;
  at(2) = x3;
  at(3) = x4;
  at(4) = x5;
  at(5) = x6;
}

HyperPoint::HyperPoint(double x1, double x2, double x3, double x4, double x5, double x6, double x7) :
  _coords(7, 0.0)
{
  at(0) = x1;
  at(1) = x2;
  at(2) = x3;
  at(3) = x4;
  at(4) = x5;
  at(5) = x6;
  at(6) = x7;
}



double HyperPoint::multiplyElements() const{
  double total = 1.0;
  for (int i = 0; i < size(); i++) total *= this->at(i);
  return total;
}

bool HyperPoint::compatible(const HyperPoint & other, bool printError) const{

  if (getDimension() != other.getDimension()) {
    if (printError == true) ERROR_LOG << "HyperPoints are of different dimension i.e. not compatible!!!"; 
    return 0;
  }
  return 1;

}

double HyperPoint::distanceTo(const HyperPoint & other) const{
  if (this->compatible(other) == 0) return 0.0; 
  HyperPoint temp = other - *this;
  return temp.norm();
}

double HyperPoint::norm() const{
  double normVal = 0.0;
  for (int i = 0; i < size(); i++) normVal += at(i)*at(i);
  return sqrt(normVal);
}

double HyperPoint::norm2() const{
  double normVal = 0.0;
  for (int i = 0; i < size(); i++) normVal += at(i)*at(i);
  return normVal;
}

double     HyperPoint::dotProduct(const HyperPoint & other) const{
  if (this->compatible(other) == 0) return 0.0; 

  double val = 0.0;
  for (int i = 0; i < size(); i++) val += at(i)*other.at(i);
  return val;
}

void       HyperPoint::fillRandom(double min, double max){

  for(int i = 0; i < size(); i++) at(i) = gRandom->Uniform(min,max);
}

HyperPoint HyperPoint::project(const HyperPoint & other) const{
  if (this->compatible(other) == 0) return *this; 

  HyperPoint projection(*this);
  double scale = this->dotProduct(other) / this->dotProduct(*this);
  return (projection * scale);
}

HyperPoint& HyperPoint::operator= (const HyperPoint & other){
  //if (this->compatible(other) == 0) return *this; 
  
  _coords  = other._coords;
  _weights = other._weights;
  
  return *this;
}

HyperPoint HyperPoint::operator+ (const HyperPoint & other) const{

  if (this->compatible(other) == 0) return *this; 

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) + other.at(i);
  
  return temp;

}

HyperPoint HyperPoint::operator- (const HyperPoint & other) const{

  if (this->compatible(other) == 0) return *this; 

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) - other.at(i);
  
  return temp;

}

HyperPoint HyperPoint::operator- (const double & other) const{

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) - other;

  return temp;

}

HyperPoint HyperPoint::operator+ (const double & other) const{

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) + other;

  return temp;

}

HyperPoint HyperPoint::operator/ (const double & other) const{

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) / other;

  return temp;

}

HyperPoint HyperPoint::operator* (const double & other) const{

  HyperPoint temp(size());

  for (int i = 0; i < size(); i++) temp.at(i) = this->at(i) * other;

  return temp;

}

HyperPoint HyperPoint::linearTransformation( const TMatrixD& matrix ){

  HyperPoint point(getDimension());

  for (int i = 0; i < getDimension(); i++){
    double val = 0.0;
    for (int j = 0; j < getDimension(); j++){
      val += at(j)*matrix(i,j);
    }
    point.at(i) = val;
  }

  return point;

} 

bool HyperPoint::operator <(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) < other.at(i)) return true;
    if (this->at(i) > other.at(i)) return false;
  }
  return false;
}

bool HyperPoint::operator >(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) < other.at(i)) return false;
    if (this->at(i) > other.at(i)) return true;
  }
  return false;
}

bool HyperPoint::operator <=(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) < other.at(i)) return true;
    if (this->at(i) > other.at(i)) return false;
  }
  return true;
}

bool HyperPoint::operator >=(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) < other.at(i)) return false;
    if (this->at(i) > other.at(i)) return true;
  }
  return true;
}

bool HyperPoint::allLT (const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) >= other.at(i)) return false;
  }
  return true;
}

bool HyperPoint::allGT  (const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) <= other.at(i)) return false;
  }
  return true;
}

bool HyperPoint::allLTOE(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 

  for (int i = 0; i < size(); i++) {
    if (this->at(i) > other.at(i)) return false;
  }
  return true;
}

bool HyperPoint::allGTOE(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 
  
  for (int i = 0; i < size(); i++) {
    if (this->at(i) < other.at(i)) return false;
  }
  return true;
}

bool HyperPoint::operator ==(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 
  
  for (int i = 0; i < size(); i++) if (this->at(i) != other.at(i)) return false;
  return true;
}

bool HyperPoint::operator !=(const HyperPoint& other) const{
  if (this->compatible(other) == 0) return false; 
  
  for (int i = 0; i < size(); i++) if (this->at(i) != other.at(i)) return true;
  return false;
}

bool HyperPoint::operator <(const double& other) const{
  for (int i = 0; i < size(); i++) if ((this->at(i) < other)==0) return false;
  return true;
}

bool HyperPoint::operator >(const double& other) const{
  for (int i = 0; i < size(); i++) if ((this->at(i) > other)==0) return false;
  return true;
}

bool HyperPoint::operator <=(const double& other) const{
  for (int i = 0; i < size(); i++) if ((this->at(i) <= other)==0) return false;
  return true;
}

bool HyperPoint::operator >=(const double& other) const{
  for (int i = 0; i < size(); i++) if ((this->at(i) >= other)==0) return false;
  return true;
}

bool HyperPoint::operator ==(const double& other) const{
  for (int i = 0; i < size(); i++) if ((this->at(i) == other)==0) return false;
  return true;
}

const double& HyperPoint::at  (int i) const{
  if (i >= this->size()) {
    ERROR_LOG << "The component of this HyperPoint you have selected is out of range";
    return _coords.at(this->size() - 1);
  }
  return _coords.at(i);
}

double& HyperPoint::at  (int i){
  if (i >= size()) {
    ERROR_LOG << "The component of this HyperPoint you have selected is out of range";
    return _coords.at(size() - 1);
  }
  return _coords.at(i);
}

void HyperPoint::print(std::ostream& os, int endline) const{
  
  std::ostringstream oss; 

  oss << "( ";
  for(int i = 0; i < (size() - 1); i++){
    oss << std::setw(10) << std::left << _coords.at(i) << ", ";
  }
  if (size() != 0) oss << std::setw(10) << std::left << _coords.at(size() - 1);
  oss << ")";    
  
  this->printWeight(oss, 0);

  if (endline) oss << std::endl;

  os << oss.str();
}

std::ostream& operator<<(std::ostream& os, const HyperPoint& point) {
  point.print(os, 0);
  return os;
} 

HyperPoint::~HyperPoint(){
}