MultiDimensionalVector.impl.h

/*
    Hyperspace Explorer - vizualizing higher-dimensional geometry
    Copyright (C) 2009-2010  Lene Preuss <lene.preuss@gmail.com>

    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 2 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, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#include "MultiDimensionalVector.h"

#include <algorithm>
#include <sstream>
#include <iostream>
#include <iterator>

namespace VecMath {

template <typename T, unsigned D>
MultiDimensionalVector<T, D>::MultiDimensionalVector(): _data() { }

template <typename T, unsigned D>
MultiDimensionalVector<T, D>::MultiDimensionalVector(unsigned n): _data(n) { }

template <typename T, unsigned D>
MultiDimensionalVector<T, D>::MultiDimensionalVector(
    typename std::vector<MultiDimensionalVector<T, D-1> >::iterator first,
    typename std::vector<MultiDimensionalVector<T, D-1> >::iterator last):
  MultiDimensionalVector<T, D-1>(),
  _data(first, last) { }

template <typename T, unsigned D>
MultiDimensionalVector<T, D>::MultiDimensionalVector(const MultiDimensionalVector<T, D> &v):
  MultiDimensionalVector<T, D-1>(),
  _data(v.data()) { }

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::iterator
MultiDimensionalVector<T, D>::begin() {
  return data().begin();
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::iterator
MultiDimensionalVector<T, D>::end() {
  return data().end();
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::const_iterator
MultiDimensionalVector<T, D>::begin() const {
  return data().begin();
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::const_iterator
MultiDimensionalVector<T, D>::end() const {
  return data().end();
}

template <typename T, unsigned D>
void MultiDimensionalVector<T, D>::push_back(const MultiDimensionalVector<T, D-1> &x) {
  data().push_back(x);
}

template <typename T, unsigned D>
MultiDimensionalVector<T, D-1> &MultiDimensionalVector<T, D>::back() {
    return data().back();
}
      
template <typename T, unsigned D>
const MultiDimensionalVector<T, D-1> &MultiDimensionalVector<T, D>::back() const {
    return data().back();
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::iterator
MultiDimensionalVector<T, D>::erase(iterator position) {
  return data().erase(position);
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::iterator
MultiDimensionalVector<T, D>::erase(iterator first, iterator last) {
  return data().erase(first, last);
}

template <typename T, unsigned D>
MultiDimensionalVector<T, D-1> &MultiDimensionalVector<T, D>::operator [] (unsigned i) {
  return data()[i];
}

template <typename T, unsigned D>
const MultiDimensionalVector<T, D-1> &MultiDimensionalVector<T, D>::operator [] (unsigned i) const {
  return data()[i];
}

template <typename T, unsigned D>
unsigned MultiDimensionalVector<T, D>::size() const {
  return data().size();
}

template <typename T, unsigned D>
unsigned MultiDimensionalVector<T, D>::empty() const {
  return data().empty();
}

template <typename T, unsigned D> void MultiDimensionalVector<T, D>::clear() {
  for (typename MultiDimensionalVector<T, D>::iterator i = data().begin(); i != data().end(); ++i) {
    i->clear();
  }
  data().clear();
}

template <typename T, unsigned D>
void MultiDimensionalVector<T, D>::resize(unsigned new_size) {
  data().resize(new_size);
}

template <typename T, unsigned D>
void MultiDimensionalVector<T, D>::resize(unsigned new_size, MultiDimensionalVector<T, D-1> x) {
  data().resize(new_size, x);
}

template <typename T, unsigned D>
void MultiDimensionalVector<T, D>::reserve(unsigned new_size) {
  data().reserve(new_size);
}

template <typename T, unsigned D>
bool MultiDimensionalVector<T, D>::operator == (const MultiDimensionalVector<T, D> &other) const {
  return data() == other.data();
}

template <typename T, unsigned D>
bool MultiDimensionalVector<T, D>::operator != (const MultiDimensionalVector<T, D> &other) const {
  return data() != other.data();
}

template <typename T, unsigned D>
template <typename Function>
Function MultiDimensionalVector<T, D>::for_each(Function f) {
  for (iterator i = begin(); i != end(); ++i) {
    f = i->for_each(f);
  }
  return f;
}

template <typename T, unsigned D>
template <typename Function>
Function MultiDimensionalVector<T, D>::for_each(Function f) const {
  for (const_iterator i = begin(); i != end(); ++i) {
    f = i->for_each(f);
  }
  return f;
}

template <typename T, unsigned D>
std::string MultiDimensionalVector<T, D>::toString() const {
  std::ostringstream o;
  o << *this;
  return o.str();
}

template <typename T, unsigned D>
void MultiDimensionalVector<T, D>::print() const {
  std::cerr << data().size() << " elements: " << "< ";
  for (typename std::vector<MultiDimensionalVector<T, D-1> >::const_iterator
       i = data().begin();
       i != data().end(); ++i) {
    i->print();
  }
  std::cerr << " >" << std::endl;
}

template <typename T, unsigned D>
std::vector<MultiDimensionalVector<T, D-1> > &MultiDimensionalVector<T, D>::data() {
  return _data;
}

template <typename T, unsigned D>
const std::vector<MultiDimensionalVector<T, D-1> > &MultiDimensionalVector<T, D>::data() const {
  return _data;
}

template<typename T, unsigned D>
std::ostream& operator<<(std::ostream& s, MultiDimensionalVector<T, D> const& v) {

  if (MultiDimensionalVector<T, 1>::print_num_elements()) s << v.size() << " elements: ";

  for (unsigned i = MultiDimensionalVector<T, 1>::max_dimension(); i > D; --i) s << "  ";

  s << "(\n";

  copy(v.begin(), v.end(), std::ostream_iterator<MultiDimensionalVector<T, D-1> >(s, "\n"));

  for (unsigned i = MultiDimensionalVector<T, 1>::max_dimension(); i > D; --i) s << "  ";

  s << ")";

  return s;
}

template <typename T, unsigned D>
typename MultiDimensionalVector<T, D>::iterator find(MultiDimensionalVector<T, D-1> const &find_me,
                                                     MultiDimensionalVector<T, D> &v) {
  typename MultiDimensionalVector<T, D>::iterator i = v.begin();
  while(*i != find_me && i != v.end()) ++i;
  return i;
}

template<typename T1, typename T2, unsigned D, typename Function>
Function for_each(MultiDimensionalVector<T1, D> &v1,
                  MultiDimensionalVector<T2, D> &v2,
                  Function f) {
  size_t max_element = std::min(v1.size(), v2.size());
  for (size_t i = 0; i < max_element; ++i) {
    f = for_each(v1[i], v2[i], f);
  }
  return f;
}

template<typename T1, typename T2, unsigned D, typename Function>
Function for_each(const MultiDimensionalVector<T1, D> &v1,
                  const MultiDimensionalVector<T2, D> &v2,
                  Function f) {
  size_t max_element = std::min(v1.size(), v2.size());
  for (size_t i = 0; i < max_element; ++i) {
    f = for_each(v1[i], v2[i], f);
  }
  return f;
}

template<typename T1, typename T2, typename T3, unsigned D, typename Function>
Function for_each(MultiDimensionalVector<T1, D> &v1,
                  MultiDimensionalVector<T2, D> &v2,
                  MultiDimensionalVector<T3, D> &v3,
                  Function f) {
  size_t max_element = std::min(std::min(v1.size(), v2.size()), v3.size());
  for (size_t i = 0; i < max_element; ++i) {
    f = for_each(v1[i], v2[i], v3[i], f);
  }
  return f;
}

template<typename T1, typename T2, typename T3, unsigned D, typename Function>
Function for_each(const MultiDimensionalVector<T1, D> &v1,
                  const MultiDimensionalVector<T2, D> &v2,
                  const MultiDimensionalVector<T3, D> &v3,
                  Function f) {
  size_t max_element = std::min(std::min(v1.size(), v2.size()), v3.size());
  for (size_t i = 0; i < max_element; ++i) {
    f = for_each(v1[i], v2[i], v3[i], f);
  }
  return f;
}


template <typename T>
MultiDimensionalVector<T, 1>::MultiDimensionalVector(): _data() { }

template <typename T>
MultiDimensionalVector<T, 1>::MultiDimensionalVector(unsigned n): _data(n) { }

template <typename T>
MultiDimensionalVector<T, 1>::MultiDimensionalVector(std::vector<T> data): _data(data) { }

template <typename T>
typename MultiDimensionalVector<T, 1>::iterator
MultiDimensionalVector<T, 1>::begin() {
  return data().begin();
}

template <typename T>
typename MultiDimensionalVector<T, 1>::iterator
MultiDimensionalVector<T, 1>::end() {
  return data().end();
}

template <typename T>
typename MultiDimensionalVector<T, 1>::const_iterator
MultiDimensionalVector<T, 1>::begin() const {
  return data().begin();
}

template <typename T>
typename MultiDimensionalVector<T, 1>::const_iterator
MultiDimensionalVector<T, 1>::end() const {
  return data().end();
}

template <typename T>
void MultiDimensionalVector<T, 1>::push_back(const T &x) {
  data().push_back(x);
}

template <typename T>
T &MultiDimensionalVector<T, 1>::back() {
    return data().back();
}
      
template <typename T>
const T &MultiDimensionalVector<T, 1>::back() const {
    return data().back();
}

template <typename T>
typename MultiDimensionalVector<T, 1>::iterator
MultiDimensionalVector<T, 1>::erase(iterator position) {
  return data().erase(position);
}

template <typename T>
typename MultiDimensionalVector<T, 1>::iterator
MultiDimensionalVector<T, 1>::erase(iterator first, iterator last) {
  return data().erase(first, last);
}

template <typename T>
T &MultiDimensionalVector<T, 1>::operator [] (unsigned i) {
  return data()[i];
}

template <typename T>
const T &MultiDimensionalVector<T, 1>::operator [] (unsigned i) const {
  return data()[i];
}

template <typename T>
unsigned MultiDimensionalVector<T, 1>::size() const {
  return data().size();
}

template <typename T>
unsigned MultiDimensionalVector<T, 1>::empty() const {
  return data().empty();
}

template <typename T>
void MultiDimensionalVector<T, 1>::clear() {
  data().clear();
}

template <typename T>
void MultiDimensionalVector<T, 1>::resize(unsigned new_size) {
  data().resize(new_size);
}

template <typename T>
void MultiDimensionalVector<T, 1>::resize(unsigned new_size, T x) {
  data().resize(new_size, x);
}

template <typename T>
void MultiDimensionalVector<T, 1>::reserve(unsigned new_size) {
  data().reserve(new_size);
}

template <typename T>
bool MultiDimensionalVector<T, 1>::operator == (const MultiDimensionalVector<T, 1> &other) const {
  return data() == other.data();
}

template <typename T>
bool MultiDimensionalVector<T, 1>::operator != (const MultiDimensionalVector<T, 1> &other) const {
  return data() != other.data();
}

template <typename T>
template <typename Function>
Function MultiDimensionalVector<T, 1>::for_each(Function f) {
  return std::for_each(begin(), end(), f);
}

template <typename T>
template <typename Function>
Function MultiDimensionalVector<T, 1>::for_each(Function f) const {
  return std::for_each(begin(), end(), f);
}

template <typename T>
std::string MultiDimensionalVector<T, 1>::toString() const {
  std::ostringstream o;
  o << *this;
  return o.str();
}

template <typename T>
void MultiDimensionalVector<T, 1>::print() const {
  std::cerr << "< ";
  for (typename std::vector<T>::const_iterator i = data().begin();
       i != data().end(); ++i) {
    std::cerr << *i << " ";
  }
  std::cerr << "> ";
}

template <typename T>
bool MultiDimensionalVector<T, 1>::print_num_elements() {
  return PRINT_NUM_ELEMENTS;
}

template <typename T>
unsigned MultiDimensionalVector<T, 1>::max_dimension() {
  return MAX_DIMENSION;
}

template <typename T>
std::vector<T> &MultiDimensionalVector<T, 1>::data() {
  return _data;
}

template <typename T>
const std::vector<T> &MultiDimensionalVector<T, 1>::data() const {
  return _data;
}


template<typename T>
std::ostream& operator<<(std::ostream& s, MultiDimensionalVector<T, 1> const& v) {

  if (MultiDimensionalVector<T, 1>::print_num_elements()) s << v.size() << " elements: ";
  for (unsigned i = MultiDimensionalVector<T, 1>::max_dimension(); i > 1; --i) s << "  ";
  s << "(";
  copy(v.begin(), v.end(), std::ostream_iterator<T>(s, " "));
  for (unsigned i = MultiDimensionalVector<T, 1>::max_dimension(); i > 1; --i) s << "  ";
  s << ")";
  return s;

}


template<typename T1, typename T2, typename Function>
Function for_each(MultiDimensionalVector<T1, 1> &v1,
                  MultiDimensionalVector<T2, 1> &v2,
                  Function f) {
  size_t max_element = std::min(v1.size(), v2.size());
  for (size_t i = 0; i < max_element; ++i) {
    f(v1[i], v2[i]);
  }
  return f;
}

template<typename T1, typename T2, typename Function>
Function for_each(const MultiDimensionalVector<T1, 1> &v1,
                  const MultiDimensionalVector<T2, 1> &v2,
                  Function f) {
  size_t max_element = std::min(v1.size(), v2.size());
  for (size_t i = 0; i < max_element; ++i) {
    f(v1[i], v2[i]);
  }
  return f;
}

template<typename T1, typename T2, typename T3, typename Function>
Function for_each(MultiDimensionalVector<T1, 1> &v1,
                  MultiDimensionalVector<T2, 1> &v2,
                  MultiDimensionalVector<T3, 1> &v3,
                  Function f) {
  size_t max_element = std::min(std::min(v1.size(), v2.size()), v3.size());
  for (size_t i = 0; i < max_element; ++i) {
    f(v1[i], v2[i], v3[i]);
  }
  return f;
}

template<typename T1, typename T2, typename T3, typename Function>
Function for_each(const MultiDimensionalVector<T1, 1> &v1,
                  const MultiDimensionalVector<T2, 1> &v2,
                  const MultiDimensionalVector<T3, 1> &v3,
                  Function f) {
  size_t max_element = std::min(std::min(v1.size(), v2.size()), v3.size());
  for (size_t i = 0; i < max_element; ++i) {
    f(v1[i], v2[i], v3[i]);
  }
  return f;
}


}