zd_f_vector.hpp

/* zd_f_vector.hpp */
/* $Id: zd_f_vector.hpp 20080 2009-12-15 15:57:52Z vlad $ */

/*
 *  $Log: zd_f_vector.hpp,v $
 *  Revision 1.8  2008/04/23 13:20:00  vlad
 *  Fixed order of initializations.
 *
 *  Revision 1.7  2007/04/13 19:42:18  vlad
 *  + argStep() and setFunc() impementation.
 *  + check for index in range in func()
 *
 *  Revision 1.6  2006/06/07 14:27:08  guser4
 *  Right order of member initialization.
 *
 *  Revision 1.5  2006/06/01 10:26:03  guser4
 *  Fixed bug in arg() for constant argument step data.
 *
 *  Revision 1.4  2006/04/24 08:31:02  guser1
 *  Use m_nPoints instead of m_nSamples/
 *
 *  Revision 1.3  2006/04/13 14:55:16  vlad
 *  Fixed cut&paste typo.
 *
 *  Revision 1.2  2006/03/12 01:39:51  rus1
 *  Fixed stupid bugs.
 *
 *  Revision 1.1  2006/03/07 10:53:00  rus1
 *  + ZdFVector template.
 *
 */

#ifndef __zd_f_vector_hpp
#define __zd_f_vector_hpp

#include "zqb_macros.h"
#include "zd_function.hpp"


#ifndef __zd_f_vector_global_vars

extern int  g_iZdFVectorCounter;

extern char*    g_szZdFVectorOwnType;

#endif /* __zd_f_vector_global_vars */


template <class T>
class ZdFVector : public ZdFunction
{
private:

  int       m_nPoints;

  T     *m_pFunc, *m_pArg;

  const T   *m_pFuncC, *m_pArgC;

  std::vector<T>    *m_vFunc, *m_vArg;

  double    m_fArg0;

  double    m_fArgStep;

public:

  ZdFVector (int n, T* pFunc, double fArgStep = 1.0, double fArg0 = 0.0)
    : ZqbAutoName(&g_iZdFVectorCounter, g_szZdFVectorOwnType),
      m_nPoints(n),
      m_pFunc(pFunc), m_pArg(NULL),
      m_pFuncC(NULL), m_pArgC(NULL),
      m_vFunc(NULL), m_vArg(NULL),
      m_fArg0(fArg0), m_fArgStep(fArgStep)
  {
    if(NULL == m_pFunc || m_nPoints < 0)
      m_nPoints = 0;
  }

  ZdFVector (int n, T* pArg, T* pFunc)
    : ZqbAutoName(&g_iZdFVectorCounter, g_szZdFVectorOwnType),
      m_nPoints(n),
      m_pFunc(pFunc), m_pArg(pArg),
      m_pFuncC(NULL), m_pArgC(NULL),
      m_vFunc(NULL), m_vArg(NULL),
      m_fArg0(0.0), m_fArgStep(0.0)
  {
    if(NULL == m_pArg || NULL == m_pFunc || m_nPoints < 0)
      m_nPoints = 0;
  }

  ZdFVector (int n, const T* pArg, const T* pFunc)
    : ZqbAutoName(&g_iZdFVectorCounter, g_szZdFVectorOwnType),
      m_nPoints(n),
      m_pFunc(NULL), m_pArg(NULL),
      m_pFuncC(pFunc), m_pArgC(pArg),
      m_vFunc(NULL), m_vArg(NULL),
      m_fArg0(0.0), m_fArgStep(0.0)
  {
    if(NULL == m_pArg || NULL == m_pFunc || m_nPoints < 0)
      m_nPoints = 0;
  }

  ZdFVector (std::vector<T>* pvArg, std::vector<T>* pvFunc)
    : ZqbAutoName(&g_iZdFVectorCounter, g_szZdFVectorOwnType),
      m_nPoints(0),
      m_pFunc(NULL), m_pArg(NULL),
      m_pFuncC(NULL), m_pArgC(NULL),
      m_vFunc(pvFunc), m_vArg(pvArg),
      m_fArg0(0.0), m_fArgStep(0.0)
  {
    if(NULL == m_vArg || NULL == m_vFunc)
      m_nPoints = 0;
    else
      m_nPoints = ZqbMIN(m_vArg->size(), m_vFunc->size());
  }

  virtual ~ZdFVector () {
    /* Nothing to do */
  }

  virtual int       count () {
    return m_nPoints;
  }
    
  virtual double    argStep () {
    if(NULL != m_pArg || NULL != m_pArgC || NULL != m_vArg)
      return 0.0;
    return m_fArgStep;
  }

  virtual double    arg (int i) {
    if(NULL != m_pArg)
      return m_pArg[i];
    else if(NULL != m_pArgC)
      return m_pArgC[i];
    else if(NULL != m_vArg)
      return (*m_vArg)[i];
    return m_fArg0 + m_fArgStep * i;
  }
    
  virtual double    func (int i) {
    if(i < 0 || i >= count())
      return 0.0;
    else if(NULL != m_pFunc)
      return m_pFunc[i];
    else if(NULL != m_pFuncC)
      return m_pFuncC[i];
    else if(NULL != m_vFunc)
      return (*m_vFunc)[i];
    return 0.0;
  }

  virtual void  setFunc (int i, double fNewValue) {
    if(i < 0 || i >= count())
      return;
    if(NULL != m_pFunc)
      m_pFunc[i] = fNewValue;
    else if(NULL != m_vFunc)
      (*m_vFunc)[i] = fNewValue;
  }

};


/*
 *  Common use derivations
 */

typedef class ZdFVector<int>    ZdFVectorInt;
typedef class ZdFVector<float>  ZdFVectorFloat;
typedef class ZdFVector<double> ZdFVectorDouble;


#endif /* zd_f_vector.hpp */