tuple.h

Go to the documentation of this file.

//Copyright 2010 Thomas A Caswell
//tcaswell@uchicago.edu
//http://jfi.uchicago.edu/~tcaswell
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 3 of the License, or (at
//your option) any later version.
//
//This program 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
//General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, see <http://www.gnu.org/licenses>.
//
//Additional permission under GNU GPL version 3 section 7
//
//If you modify this Program, or any covered work, by linking or
//combining it with MATLAB (or a modified version of that library),
//containing parts covered by the terms of MATLAB User License, the
//licensors of this Program grant you additional permission to convey
//the resulting work.
#ifndef TUPLE_T
#define TUPLE_T

#include <iostream>
#include <sstream>
#include <stdexcept>
#include <cmath>
namespace utilities{
template<class T,int length>
class Tuple{
public:
  bool operator==(const Tuple& b)const;
  
  void operator= (const Tuple& y);
  Tuple operator- ( );

  T& operator[] (int i);        
  const T& operator[] (int i) const;

  Tuple operator+ (const Tuple& y) const;
  Tuple operator+ (const T y)const;
  void operator+= (const Tuple& y);
  void operator+= (const T y);



  Tuple operator- ( const Tuple& y)const;
  Tuple operator- ( const T y)const;
  void operator-= (const Tuple& y);
  void operator-= (const T y);



  Tuple operator* (const T y) const;
  Tuple operator* (const Tuple& y) const;
  void operator*= (const Tuple& y);
  void operator*= (const T y);



  Tuple operator/ ( const Tuple& y) const;
  void operator/= (const Tuple& y);
  void operator/= (const T y);



  T magnitude_sqr () const;

  T magnitude () const;

  T dot(const Tuple & y) const;
   
  T prod()const;
  
  T sum()const;

  T max()const;
  T min()const;
  
  
  void make_unit();

  Tuple direction() const;

  void print() const;

  void clear();

  Tuple();

  Tuple(const Tuple & y);

  T dist_sqr(const Tuple& y)const;
  

  ~Tuple();
  Tuple(T x);

  Tuple(T x,T y);
  Tuple(T x,T y,T z);
  
  Tuple(const T * );

  
  const T * get_ptr() const;
  
  T * get_ptr() ;
  
  const static int length_ = length;
  
  template<class T2>
  Tuple<T,length>(const Tuple<T2,length>&);
  

  int get_len()const
  {
    return length;
  }
  
protected:
  T data_[length];

private:
};

  
template<typename _CharT, class _Traits,class T,int length>
std::basic_ostream<_CharT, _Traits>&
operator<<(std::basic_ostream<_CharT, _Traits>& __os, const Tuple<T,length>& in)
{

    
  std::basic_ostringstream<_CharT, _Traits> s;
  s.flags(__os.flags());
  s.imbue(__os.getloc());
  s.precision(__os.precision());

    
  s << '(' ;
  s<< in[0]  ;
  for(int j = 1;j<in.get_len();++j)
    s<< ','<<in[j]  ;
  s << ')';

  return __os << s.str();
}


template<class T,int length>
bool Tuple<T,length>::operator==(const Tuple<T,length>& b)const
{
  for(int j = 0;j<length; ++j)
    if(data_[j] != b.data_[j])
      return false;
  return true;
}

template<class T,int length>
void Tuple<T,length>::operator= (const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] = y.data_[j];
}
template<class T,int length>
T& Tuple<T,length>::operator[] (int i){
  if(i<0 || i>= length)
    throw std::runtime_error("Tuple range error");
  return data_[i];
}
template<class T,int length>
const T& Tuple<T,length>::operator[] (int i) const{
  if(i<0 || i>= length)
    throw std::runtime_error("Tuple range error");
  return data_[i];
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator- (){
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = -data_[j];
  return tmp;
}
template<class T,int length>

Tuple<T,length> Tuple<T,length>::operator+ (const Tuple<T,length>& y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = y.data_[j] + data_[j];
  return tmp;
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator+ (const T y)const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = y + data_[j];
  return tmp;
}
template<class T,int length>
void Tuple<T,length>::operator+= (const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] += y.data_[j] ;

}
template<class T,int length>
void Tuple<T,length>::operator+= (const T y){
  for(int j = 0;j<length; ++j)
    data_[j] += y ;

}

template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator- (const Tuple<T,length>& y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = -y.data_[j] + data_[j];
  return tmp;
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator- (const T y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = -y + data_[j];
  return tmp;
}
template<class T,int length>
void Tuple<T,length>::operator-= (const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] -= y.data_[j] ;

}
template<class T,int length>
void Tuple<T,length>::operator-= (const T y){
  for(int j = 0;j<length; ++j)
    data_[j] -= y ;
}


template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator* (const Tuple<T,length>& y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j){
    tmp.data_[j] = data_[j]*y.data_[j] ;
  }
  return tmp;
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator* (const T y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j){
    tmp.data_[j] = data_[j] * y ;
  }
  return tmp;
}
template<class T,int length>
void Tuple<T,length>::operator*= (const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] *= y.data_[j] ;
}
template<class T,int length>
void Tuple<T,length>::operator*= (const T y){
  for(int j = 0;j<length; ++j)
    data_[j] *= y ;
}



template<class T,int length>
void Tuple<T,length>::operator/= (const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] /= y.data_[j] ;

}
template<class T,int length>
void Tuple<T,length>::operator/= (const T y){
  for(int j = 0;j<length; ++j)
    data_[j] /= y ;
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::operator/ (const Tuple<T,length>& y) const{
  Tuple<T,length> tmp;
  for(int j = 0;j<length; ++j)
    tmp.data_[j] = data_[j]/y.data_[j] ;
  return tmp;
}




template<class T,int length>
void Tuple<T,length>::print() const{
  using std::cout;
  using std::endl;
  for(int j = 0;j<length; ++j)
    cout<<data_[j] <<"\t";
  cout<<endl;
}

template<class T,int length>
T Tuple<T,length>::magnitude_sqr() const{
  T tmp = 0;
  for(int j = 0;j<length; ++j)
    tmp += data_[j]*data_[j] ;
  return tmp;
}
template<class T,int length>
T Tuple<T,length>::magnitude() const
{
  return sqrt(magnitude_sqr());
}
template<class T,int length>
T Tuple<T,length>::dot(const Tuple<T,length> & y) const
{
  T tmp = 0;
  for(int j = 0;j<length; ++j)
    tmp += data_[j]*y.data_[j] ;
  return tmp;
}

template<class T,int length>
T Tuple<T,length>::prod()const
{
  T tmp = 1;
  for(int j = 0;j<length; ++j)
    tmp *= data_[j];
  return tmp;
  
}
template<class T,int length>
T Tuple<T,length>::sum()const
{
  T tmp = 0;
  for(int j = 0;j<length; ++j)
    tmp += data_[j];
  return tmp;
} 
template<class T,int length>
T Tuple<T,length>::max()const
{
  T tmp = data_[0];
  for(int j = 1;j<length; ++j)
    if( data_[j] > tmp)
      tmp = data_[j];
  return tmp;
} 
template<class T,int length>
T Tuple<T,length>::min()const
{
  T tmp = data_[0];
  for(int j = 1;j<length; ++j)
    if( data_[j] < tmp)
      tmp = data_[j];
  return tmp;
} 

template<class T,int length>
void Tuple<T,length>::make_unit(){
  T tmp = magnitude();
  for(int j = 0;j<length; ++j)
    data_[j] /= tmp ;
}
template<class T,int length>
Tuple<T,length> Tuple<T,length>::direction() const{
  Tuple<T,length> tmp = (*this);
  tmp.make_unit();
  return tmp;

}

template<class T,int length>
void Tuple<T,length>::clear(){
  for(int j = 0;j<length; ++j)
    data_[j] =0 ;
}

template<class T,int length>
Tuple<T,length>::Tuple(){
  //  data_= (T*) new T[length];
  for(int j = 0;j<length; ++j)
    data_[j] = 0;
  //  std::cout<<"make"<< std::endl;

}

// tac 2009-07-17
// added 
template<class T,int length>
Tuple<T,length>::Tuple(const Tuple<T,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] = y.data_[j];
}

template<class T,int length>
template<class T2>
Tuple<T,length>::Tuple(const Tuple<T2,length>& y){
  for(int j = 0;j<length; ++j)
    data_[j] = (T) y[j];
}


// tac 2009-10-07
// added because the constructors and destructors of Tuple<T,length>s are taking ~5% of run time
template<class T,int length>
T Tuple<T,length>::dist_sqr(const Tuple<T,length>& y)const
{
  T out =0;
  
  for(int j = 0;j<length;++j)
  {
    T tmp =(data_[j]-y.data_[j]);
    out += tmp*tmp;
  }
  return out;
}

template<class T,int length>
Tuple<T,length>::~Tuple(){
  //  std::cout<<"died"<< std::endl;
  // delete[] data_;
  //   data_ = NULL;
}

template<class T,int length>
Tuple<T,length>::Tuple(T x)
{
  for(int j = 0; j<length;++j)
    data_[j] = x;
}


template<class T,int length>
Tuple<T,length>::Tuple(T x,T y)
{
  if(length != 2)
    throw std::logic_error("Tuple, using wrong number of arguments for this instantiation");
  data_[0] = x;
  data_[1] = y;
}


template<class T,int length>
Tuple<T,length>::Tuple(T x,T y,T z)
{
  if(length != 3)
    throw std::logic_error("Tuple, using wrong number of arguments for this instantiation");
  
  data_[0] = x;
  data_[1] = y;
  data_[2] = z;
}

template<class T,int length>
Tuple<T,length>::Tuple(const T * in )
{
  for( int j = 0;j<length;++j)
    data_[j] = in[j];
}

template<class T,int length>
const T * Tuple<T,length>::get_ptr() const
{
  return data_;
}

template<class T,int length>
T * Tuple<T,length>::get_ptr() 
{
  return data_;
}
    
  

}

#endif