fims_vector.hpp

Go to the documentation of this file.

 
#ifndef FIMS_VECTOR_HPP
#define FIMS_VECTOR_HPP
 
#include "../interface/interface.hpp"
#include <ostream>
#include <iomanip>
 
namespace fims {
 
template <typename Type>
class Vector {
  std::vector<Type> vec_m;
  template <typename T>
  friend bool operator==(const fims::Vector<T> &lhs,
                         const fims::Vector<T> &rhs);
 
 public:
  // Member Types
 
  typedef
      typename std::vector<Type>::value_type value_type; 
  typedef typename std::vector<Type>::allocator_type
      allocator_type; 
  typedef typename std::vector<Type>::size_type size_type; 
  typedef typename std::vector<Type>::difference_type
      difference_type; 
  typedef typename std::vector<Type>::reference
      reference; 
  typedef typename std::vector<Type>::const_reference
      const_reference; 
  typedef typename std::vector<Type>::pointer pointer; 
  typedef typename std::vector<Type>::const_pointer
      const_pointer; 
  typedef typename std::vector<Type>::iterator iterator; 
  typedef typename std::vector<Type>::const_iterator
      const_iterator; 
  typedef typename std::vector<Type>::reverse_iterator
      reverse_iterator; 
  typedef typename std::vector<Type>::const_reverse_iterator
      const_reverse_iterator; 
  // Constructors
 
  Vector() {}
 
  Vector(size_t size, const Type &value = Type()) {
    this->vec_m.resize(size, value);
  }
 
  Vector(const Vector<Type> &other) {
    this->vec_m.resize(other.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      this->vec_m[i] = other[i];
    }
  }
 
  Vector &operator=(const Vector &other) {
    if (this != &other) {
      // clean up existing
      this->~Vector();
      // copy construct into *this
      new (this) Vector(other);
    }
    return *this;
  }
 
  Vector(const std::vector<Type> &other) { this->vec_m = other; }
 
  // TMB specific constructor
#ifdef TMB_MODEL
 
  Vector(const tmbutils::vector<Type> &other) {
    this->vec_m.resize(other.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      this->vec_m[i] = other[i];
    }
  }
 
#endif
 
  Vector(std::initializer_list<Type> init) {
    this->vec_m = std::vector<Type>(init);
  }
 
  inline Type &operator[](size_t pos) {
    if (pos >= this->size()) {
      throw std::invalid_argument("fims::Vector out of bounds");
    }
    return this->vec_m[pos];
  }
 
  inline const Type &operator[](size_t n) const {
    if (n >= this->size()) {
      throw std::invalid_argument("fims::Vector out of bounds");
    }
    return this->vec_m[n];
  }
 
  inline Type &at(size_t n) { return this->vec_m.at(n); }
 
  inline const Type &at(size_t n) const { return this->vec_m.at(n); }
 
  inline Type &get_force_scalar(size_t pos) {
    if (this->size() == 1 && pos > 0) {
      return this->at(0);
    } else if (this->size() > 1 && pos >= this->size()) {
      throw std::invalid_argument(
          "fims::Vector index out of bounds, check parameter sizes of input.");
    } else {
      return this->at(pos);
    }
  }
 
  inline reference front() { return this->vec_m.front(); }
 
  inline const_reference front() const { return this->vec_m.front(); }
 
  inline reference back() { return this->vec_m.back(); }
 
  inline const_reference back() const { return this->vec_m.back(); }
 
  inline pointer data() { return this->vec_m.data(); }
 
  inline const_pointer data() const { return this->vec_m.data(); }
 
  // iterators
 
  inline iterator begin() { return this->vec_m.begin(); }
 
  inline iterator end() { return this->vec_m.end(); }
 
  inline reverse_iterator rbegin() { return this->vec_m.rbegin(); }
 
  inline reverse_iterator rend() { return this->vec_m.rend(); }
 
  inline const_reverse_iterator rbegin() const { return this->vec_m.rbegin(); }
 
  inline const_reverse_iterator rend() const { return this->vec_m.rend(); }
 
  // capacity
 
  inline bool empty() { return this->vec_m.empty(); }
 
  inline size_type size() const { return this->vec_m.size(); }
 
  inline size_type max_size() const { return this->vec_m.max_size(); }
 
  inline void reserve(size_type cap) { this->vec_m.reserve(cap); }
 
  inline size_type capacity() { return this->vec_m.capacity(); }
 
  inline void shrink_to_fit() { this->vec_m.shrink_to_fit(); }
 
  // modifiers
 
  inline void clear() { this->vec_m.clear(); }
 
  inline iterator insert(const_iterator pos, const Type &value) {
    return this->vec_m.insert(pos, value);
  }
 
  inline iterator insert(const_iterator pos, size_type count,
                         const Type &value) {
    return this->vec_m.insert(pos, count, value);
  }
 
  template <class InputIt>
  iterator insert(const_iterator pos, InputIt first, InputIt last) {
    return this->vec_m.insert(pos, first, last);
  }
 
  iterator insert(const_iterator pos, std::initializer_list<Type> ilist) {
    return this->vec_m.insert(pos, ilist);
  }
 
  template <class... Args>
  iterator emplace(const_iterator pos, Args &&...args) {
    return this->vec_m.emplace(pos, std::forward<Args>(args)...);
  }
 
  inline iterator erase(iterator pos) { return this->vec_m.erase(pos); }
 
  inline iterator erase(iterator first, iterator last) {
    return this->vec_m.erase(first, last);
  }
 
  inline void push_back(const Type &&value) { this->vec_m.push_back(value); }
 
  template <class... Args>
  void emplace_back(Args &&...args) {
    this->vec_m.emplace_back(std::forward<Args>(args)...);
  }
 
  inline void pop_back() { this->vec_m.pop_back(); }
 
  inline void resize(size_t s) { this->vec_m.resize(s); }
 
  inline void swap(Vector &other) { this->vec_m.swap(other.vec_m); }
 
  // end std::vector functions
 
  inline operator std::vector<Type>() { return this->vec_m; }
 
#ifdef TMB_MODEL
 
  explicit operator tmbutils::vector<Type>() const {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }
 
  tmbutils::vector<Type> to_tmb() const {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }
 
  explicit operator tmbutils::vector<Type>() {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }
 
  tmbutils::vector<Type> to_tmb() {
    tmbutils::vector<Type> ret(this->vec_m.size());
    for (size_t i = 0; i < this->vec_m.size(); i++) {
      ret[i] = this->vec_m[i];
    }
    return ret;
  }
 
#else
 
  std::vector<Type> to_std() const { return this->vec_m; }
 
  std::vector<Type> to_tmb() const { return this->vec_m; }
#endif
 
  std::string get_tag() const { return this->tag_m; }
  void set_tag(const std::string &tag) { this->tag_m = tag; }
 
 private:
  std::string tag_m; 
};  // end fims::Vector class
 
template <class T>
bool operator==(const fims::Vector<T> &lhs, const fims::Vector<T> &rhs) {
  return lhs.vec_m == rhs.vec_m;
}
 
}  // namespace fims
 
template <typename Type>
std::ostream &operator<<(std::ostream &out, const fims::Vector<Type> &v) {
  out << std::fixed << std::setprecision(10);
  out << "[";
 
  if (v.size() == 0) {
    out << "]";
    return out;
  }
  for (size_t i = 0; i < v.size() - 1; i++) {
    if (v[i] != v[i]) {
      out << "-999" << ",";
    } else {
      out << v[i] << ",";
    }
  }
  if (v[v.size() - 1] != v[v.size() - 1]) {
    out << "-999]";
  } else {
    out << v[v.size() - 1] << "]";
  }
  return out;
}
 
#endif