zd_f3d_matrix.hpp

/* zd_f3d_matrix.hpp */
/* $Id: zd_f3d_matrix.hpp 20080 2009-12-15 15:57:52Z vlad $ */
#ifndef __zd_f3d_matrix_hpp
#define __zd_f3d_matrix_hpp

#include <math.h>
#include <string.h>

#include "zqb_macros.h"
#include "zd_function3d.hpp"


typedef enum
{
  Z_F3DM_ALA_C,     
  Z_F3DM_ALA_FORTRAN    
}   ZdF3DMatrixPolicy;


#ifndef __zd_f3d_matrix_global_vars

extern int  g_iZdF3DMatrixCounter;

extern char*    g_szZdF3DMatrixOwnType;

#endif /* __zd_f3d_matrix_global_vars */


template <class T>
class ZdF3DMatrix : public ZdFunction3D
{
private:

  struct {
    int     nCount; 
    double  fOffset;
    double  fStep;  
  }     m_X, m_Y;

  bool      m_bKnownMM;

  double        m_fMinMax[2];

  ZdF3DMatrixPolicy m_eStPolicy;

  const T*  m_pZMatrix;

  T*        m_pDetached;

public:

  ZdF3DMatrix (int nX, int nY, double pfXYInfo[4] = NULL,
           ZdF3DMatrixPolicy ePolicy = Z_F3DM_ALA_C)
    : ZqbAutoName(&g_iZdF3DMatrixCounter, g_szZdF3DMatrixOwnType),
      m_bKnownMM(false), m_eStPolicy(ePolicy),
      m_pZMatrix(NULL), m_pDetached(NULL)
  {
    m_X.nCount = nX;
    m_Y.nCount = nY;

    if(NULL == pfXYInfo)
      {
    m_X.fOffset = 0.0;
    m_Y.fOffset = 0.0;
    m_X.fStep = 1.0;
    m_Y.fStep = 1.0;
      }
    else
      {
    m_X.fOffset = pfXYInfo[0];
    m_Y.fOffset = pfXYInfo[1];
    m_X.fStep = pfXYInfo[2];
    m_Y.fStep = pfXYInfo[3];
      }

    /* Allocate memory and copy the array into it. */
    m_pDetached = new T[m_X.nCount * m_Y.nCount];
    m_pZMatrix = m_pDetached;

    /* Fill the array by zeros (regarding IEEE floating point format) */
    memset(m_pDetached, 0, sizeof(T) * m_X.nCount * m_Y.nCount);
    m_fMinMax[0] = m_fMinMax[1] = 0.0;
  }


  ZdF3DMatrix (const T* pArray, int nX, int nY, double pfXYInfo[4] = NULL,
           bool bDetached = true, ZdF3DMatrixPolicy ePolicy = Z_F3DM_ALA_C)
    : ZqbAutoName(&g_iZdF3DMatrixCounter, g_szZdF3DMatrixOwnType),
      m_pZMatrix(pArray), m_pDetached(NULL),
      m_bKnownMM(false), m_eStPolicy(ePolicy)
  {
    m_X.nCount = nX;
    m_Y.nCount = nY;

    if(NULL == pfXYInfo)
      {
    m_X.fOffset = 0.0;
    m_Y.fOffset = 0.0;
    m_X.fStep = 1.0;
    m_Y.fStep = 1.0;
      }
    else
      {
    m_X.fOffset = pfXYInfo[0];
    m_Y.fOffset = pfXYInfo[1];
    m_X.fStep = pfXYInfo[2];
    m_Y.fStep = pfXYInfo[3];
      }

    if(bDetached)
      {
    /* Allocate memory and copy the array into it. */
    m_pDetached = new T[m_X.nCount * m_Y.nCount];

    /* Use instead of pArray */
    m_pZMatrix = m_pDetached;

    /* Copy the array into special internal buffer. */
    memcpy(m_pDetached, pArray, sizeof(T) * m_X.nCount * m_Y.nCount);
      }
  }

  virtual ~ZdF3DMatrix ()
  {
    delete[] m_pDetached;
  }


  /*
   *  Basic functionality for matrix contents modification
   */

  virtual void      setFunc (int iX, int iY, T value)
  {
    if(iX < 0 || iX >= countX() || iY < 0 || iY >= countY())
      return;

    if(m_eStPolicy == Z_F3DM_ALA_C)
      m_pDetached[iX + iY * countX()] = value;
    else /* FORTRAN array index convension */
      m_pDetached[iY + iX * countY()] = value;

    /* Fix min and max values */
    if(m_bKnownMM)
      {
    m_fMinMax[0] = ZqbMIN(m_fMinMax[0], (double)value);
    m_fMinMax[1] = ZqbMAX(m_fMinMax[1], (double)value);
      }
  }


  /*
   *  Basic functionality, inherited from ZdFunction3D
   */

  virtual int       countX ()
  {
    return m_X.nCount;
  }

  virtual int       countY ()
  {
    return m_Y.nCount;
  }

  virtual double    argX (int iX)
  {
    return m_X.fOffset + m_X.fStep * iX;
  }

  virtual double    argY (int iY)
  {
    return m_Y.fOffset + m_Y.fStep * iY;
  }

  virtual double    func (int iX, int iY)
  {
    if(iX < 0 || iX >= countX() || iY < 0 || iY >= countY())
      return 0.0;

    if(m_eStPolicy == Z_F3DM_ALA_C)
      return (double) m_pZMatrix[iX + iY * countX()];
    /* else FORTRAN array index convension */
    return (double) m_pZMatrix[iY + iX * countY()];
  }


  /*
   *  Extended functionality with default implementation
   */

  virtual bool      isNullAll ()
  {
    return false;
  }

  virtual bool      isNullFunc (int iX, int iY)
  {
    if(iX < 0 || iX >= countX() || iY < 0 || iY >= countY())
      return true;
    return false;
  }

  virtual double    argStepX ()
  {
    return m_X.fStep;
  }

  virtual double    argStepY ()
  {
    return m_Y.fStep;
  }

  virtual void      getArgBoundsX (double b[2])
  {
    if(NULL == b)
      return;

    if(argStepX() > 0.0)
      {
    b[0] = m_X.fOffset;
    b[1] = m_X.fOffset + (countX() - 1) * argStepX();
      }
    else
      {
    b[1] = m_X.fOffset;
    b[0] = m_X.fOffset + (countX() - 1) * argStepX();
      }
  }

  virtual void      getArgBoundsY (double b[2])
  {
    if(NULL == b)
      return;

    if(argStepY() > 0.0)
      {
    b[0] = m_Y.fOffset;
    b[1] = m_Y.fOffset + (countY() - 1) * argStepY();
      }
    else
      {
    b[1] = m_Y.fOffset;
    b[0] = m_Y.fOffset + (countY() - 1) * argStepY();
      }
  }

  virtual void      getFuncBounds (double b[2])
  {
    if(!m_bKnownMM)
      {
    /* Find min and max values among all function values */
    ZdFunction3D::getFuncBounds(m_fMinMax);
    m_bKnownMM = true;
      }

    if(NULL != b)
      {
    b[0] = (double) m_fMinMax[0];
    b[1] = (double) m_fMinMax[1];
      }
  }

  virtual int       argIndexX (double x)
  {
    double  fiX = (x - m_X.fOffset) / argStepX();
    if(fiX - (int)fiX < 0.5)
      return (int)fiX;
    return 1 + (int)fiX;
  }

  virtual int       argIndexY (double y)
  {
    double  fiY = (y - m_Y.fOffset) / argStepY();
    if(fiY - (int)fiY < 0.5)
      return (int)fiY;
    return 1 + (int)fiY;
  }

};


/*
 *  Common use derivations
 */

typedef class ZdF3DMatrix<int>      ZdF3DMatrixInt;
typedef class ZdF3DMatrix<float>    ZdF3DMatrixFloat;
typedef class ZdF3DMatrix<double>   ZdF3DMatrixDouble;


#endif /* zd_f3d_matrix.hpp */