tjvector.h

 /***************************************************************************
                          tjvector.h  -  description
                             -------------------
    begin                : Thu Feb 22 2001
    copyright            : (C) 2000-2021 by Thies Jochimsen
    email                : thies@jochimsen.de
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 
 
#ifndef TJVECTOR_H
#define TJVECTOR_H
 
#include <tjutils/tjutils.h>
#include <tjutils/tjcomplex.h>
#include <tjutils/tjtools.h>
#include <tjutils/tjstring.h>
#include <tjutils/tjlog.h>
 
class VectorComp {
 public:
  static const char* get_compName();
};
 
 
 
 
template<class T> class tjvector : public STD_vector<T> {
 
 public:
 
  tjvector(unsigned int n=0);
 
 
  tjvector(const T *array, unsigned int n);
 
 
  tjvector(const STD_vector<T>& v);
 
  tjvector(const tjvector<T>& tv);
 
  virtual ~tjvector();
 
 
  tjvector<T>& operator = (const T& value);
 
  tjvector<T>& operator = (const STD_vector<T>& vec);
 
  tjvector<T>& operator = (const tjvector<T>& tv);
 
 
  tjvector<T> operator +  (const STD_vector<T>& w) const {
    tjvector<T> result(*this);
    for(unsigned int i=0; i<length(); i++) result[i]+=w[i];
    return result;
  }
 
  tjvector<T> operator -  (const STD_vector<T>& w) const {
    tjvector<T> result(*this);
    for(unsigned int i=0; i<length(); i++) result[i]-=w[i];
    return result;
  }
 
  tjvector<T> operator *  (const STD_vector<T>& w) const {
    tjvector<T> result(*this);
    for(unsigned int i=0; i<length(); i++) result[i]*=w[i];
    return result;
  }
 
  tjvector<T> operator /  (const STD_vector<T>& w) const {
    tjvector<T> result(*this);
    for(unsigned int i=0; i<length(); i++) result[i]/=w[i];
    return result;
  }
 
  tjvector<T> operator -  () const {
    tjvector<T> result(*this);
    for(unsigned int i=0; i<length(); i++) result[i]=-result[i];
    return result;
  }
 
  friend tjvector<T> operator +  (const T& s, const STD_vector<T>& v) {
    tjvector<T> result(v);
    for(unsigned int i=0; i<v.size(); i++) result[i]+=s;
    return result;
  }
 
  tjvector<T> operator +  (const T& s) const {
    return s+(*this);
  }
 
  friend tjvector<T> operator -  (const T& s, const STD_vector<T>& v) {
    tjvector<T> result(v);
    for(unsigned int i=0; i<v.size(); i++) result[i]=s-result[i];
    return result;
  }
 
  tjvector<T> operator -  (const T& s) const {
    return -s+(*this);
  }
 
 
  friend tjvector<T> operator *  (const T& s, const STD_vector<T>& v) {
    tjvector<T> result(v);
    for(unsigned int i=0; i<v.size(); i++) result[i]=result[i]*s;
    return result;
  }
 
  tjvector<T> operator *  (const T& s) const {
    return s*(*this);
  }
 
 
  friend tjvector<T> operator /  (const T& s, const STD_vector<T>& v) {
    tjvector<T> result(v);
    for(unsigned int i=0; i<v.size(); i++) result[i]=s/result[i];
    return result;
  }
 
  tjvector<T> operator /  ( const T& s) const {
    return (T(1)/s)*(*this);
  }
 
 
  tjvector<T>& operator += ( const STD_vector<T>& v) {
    (*this)=(*this)+v;
    return (*this);
  }
 
  tjvector<T>& operator += ( const T& s) {
    (*this)=(*this)+s;
    return (*this);
  }
 
  tjvector<T>& operator -= ( const STD_vector<T>& v) {
    (*this)=(*this)-v;
    return (*this);
  }
 
  tjvector<T>& operator -= ( const T& s) {
    (*this)=(*this)-s;
    return (*this);
  }
 
 
  tjvector<T>& operator *= ( const STD_vector<T>& v) {
    (*this)=(*this)*v;
    return (*this);
  }
 
  tjvector<T>& operator *= ( const T& s) {
    (*this)=(*this)*s;
    return (*this);
  }
 
 
  tjvector<T>& operator /= ( const STD_vector<T>& v) {
    (*this)=(*this)/v;
    return (*this);
  }
 
  tjvector<T>& operator /= ( const T& s) {
    (*this)=(*this)/s;
    return (*this);
  }
 
 
  virtual tjvector<T>& resize(unsigned int newsize);
 
 
  unsigned int length () const;
 
 
  unsigned int fill_linear(const T& min,const T& max);
 
 
  T sum() const;
 
 
  tjvector<T> range(unsigned int startindex, unsigned int endindex) const;
 
 
  T maxvalue() const;
 
 
  T minvalue() const;
 
 
  T maxabs() const;
 
 
  const T* c_array() const;
 
  tjvector& set_c_array(const unsigned char* array, unsigned int n);
 
 
  T normalize();
 
 
  tjvector& interpolate(unsigned int newsize, float subpixel_shift=0.0);
 
 
  int load(const STD_string& fname);
 
  int write(const STD_string& fname, fopenMode mode=overwriteMode, LONGEST_INT nelements=-1) const;
 
 
  STD_string printbody() const;
 
  friend STD_ostream& operator << (STD_ostream& s,const tjvector<T>& v) {
    return s << "(" << v.size() << ")=" << v.printbody();
  }
 
 
 protected:
 
  // allocate aligned memory for type T (to avoid bus errors)
  static T* allocate_memory(unsigned int nelements) {return new T[nelements];}
  
 
 private:
  mutable T* c_array_cache;
 
};
 
 
//    Aliases:
 
typedef tjvector<float>       fvector;
 
typedef tjvector<double>     dvector;
 
typedef tjvector<int>        ivector;
 
 
typedef tjvector<STD_complex> cvector;
 
 
struct svector : public STD_vector<STD_string> {
 
  // some extra stuff to be compatible with STD_vector
  svector() {}
  svector(const STD_vector<STD_string>& sv) {svector::operator = (sv);}
  svector& operator = (const STD_vector<STD_string>& sv) {STD_vector<STD_string>::operator = (sv); return *this;}
 
  // interface functions for LDRarray
  unsigned char* c_array() const {return 0;}
  svector& set_c_array(const unsigned char*, unsigned int) {return *this;}
  static unsigned char* allocate_memory(unsigned int) {return 0;}
 
  // other useful functions, imitating a tjvector
  STD_string printbody() const;
};
 
 
// Stuff to re-used in odindata
STD_complex* interpolate1D(const STD_complex* data,unsigned int oldsize,unsigned int newsize, float subpixel_shift);
float* interpolate1D(const float* olddata,unsigned int oldsize,unsigned int newsize, float subpixel_shift);
double* interpolate1D(const double* olddata,unsigned int oldsize,unsigned int newsize, float subpixel_shift);
int* interpolate1D(const int* olddata,unsigned int oldsize,unsigned int newsize, float subpixel_shift);
 
//    Specialised helper functions:
 
template<class T>
STD_vector<T> list2vector(const STD_list<T>& src) {
  STD_vector<T> result; result.resize(src.size());
  unsigned int i=0;
  for(typename STD_list<T>::const_iterator it=src.begin(); it!=src.end(); ++it) {
    result[i]=(*it);
    i++;
  }
  return result;
}
 
  fvector real(const cvector& cv);
 
  fvector imag(const cvector& cv);
 
  fvector amplitude(const cvector& cv);
 
  fvector phase(const cvector& cv);
 
  cvector real2complex(const fvector& fv);
 
  dvector fvector2dvector(const fvector& fv);
 
  fvector dvector2fvector(const dvector& dv);
 
 
  svector tokens(const STD_string& tokenstring, char custom_separator=0, char escape_begin='"',  char escape_end='"');
 
 
  STD_string tokenstring(const svector& tokens,unsigned int linewidth=_DEFAULT_LINEWIDTH_);
 
 
#ifndef NO_FILEHANDLING
  svector browse_dir(const STD_string& dirname,bool only_dirs=false, bool discard_dotfiles=false);
#endif
 
 
 
#endif