CBandedGraphData Class Reference

#include <CopasiPlot.h>

Inheritance diagram for CBandedGraphData:

Collaboration diagram for CBandedGraphData:

Public Member Functions
virtual QwtDoubleRect	boundingRect () const
	CBandedGraphData ()
	CBandedGraphData (const CVector< double > &x, const CVector< double > &y1, const CVector< double > &y2, size_t size)
virtual QwtData *	copy () const
void	reallocated (const CVector< double > *pX, const CVector< double > *pY1, const CVector< double > *pY2)
void	setSize (const size_t &size)
virtual size_t	size () const
virtual double	x (size_t i) const
virtual double	y (size_t i) const
double	y1 (size_t i) const
double	y2 (size_t i) const
virtual	~CBandedGraphData ()

Protected Member Functions
CBandedGraphData &	operator= (const CBandedGraphData &rhs)

Private Attributes
size_t	mLastRectangle
size_t	mMaxSize
double	mMaxX
double	mMaxY
double	mMinX
double	mMinY
const double *	mpX
const double *	mpY1
const double *	mpY2
size_t	mSize

Detailed Description

Definition at line 78 of file CopasiPlot.h.

Constructor & Destructor Documentation

CBandedGraphData::CBandedGraphData

(

)

Definition at line 210 of file CopasiPlot.cpp.

Referenced by copy().

                                  :
  QwtData(),
  mpX(NULL),
  mpY1(NULL),
  mpY2(NULL),
  mSize(0),
  mMaxSize(0),
  mLastRectangle(0),
  mMinX(std::numeric_limits<double>::quiet_NaN()),
  mMaxX(std::numeric_limits<double>::quiet_NaN()),
  mMinY(std::numeric_limits<double>::quiet_NaN()),
  mMaxY(std::numeric_limits<double>::quiet_NaN())
{}

CBandedGraphData::CBandedGraphData	(	const CVector< double > &	x,
		const CVector< double > &	y1,
		const CVector< double > &	y2,
		size_t	size
	)

Definition at line 224 of file CopasiPlot.cpp.

References mMaxSize, mSize, and CVectorCore< CType >::size().

                                               :
  QwtData(),
  mpX(x.array()),
  mpY1(y1.array()),
  mpY2(y2.array()),
  mSize(size),
  mMaxSize(x.size()),
  mLastRectangle(0),
  mMinX(std::numeric_limits<double>::quiet_NaN()),
  mMaxX(std::numeric_limits<double>::quiet_NaN()),
  mMinY(std::numeric_limits<double>::quiet_NaN()),
  mMaxY(std::numeric_limits<double>::quiet_NaN())
{
  assert(x.size() == y1.size());
  assert(x.size() == y2.size());
  assert(mSize <= mMaxSize);
}

CBandedGraphData::~CBandedGraphData ( )

virtual

Definition at line 245 of file CopasiPlot.cpp.

{}

Member Function Documentation

QwtDoubleRect CBandedGraphData::boundingRect ( ) const

virtual

Definition at line 297 of file CopasiPlot.cpp.

References C_FLOAT64, min, mLastRectangle, mMaxX, mMaxY, mMinX, mMinY, mpX, mpY1, mpY2, and mSize.

{
  if (mSize <= 0)
    return QwtDoubleRect(1.0, 1.0, -2.0, -2.0); // invalid

  if (mLastRectangle == mSize)
    return QwtDoubleRect(mMinX, mMinY, mMaxX - mMinX, mMaxY - mMinY);

  const double *xIt = mpX + mLastRectangle;
  const double *yIt1 = mpY1 + mLastRectangle;
  const double *yIt2 = mpY2 + mLastRectangle;
  const double *end = mpX + mSize;

  mLastRectangle = mSize;

  // We have to remember whether we have an initial NaN
  bool MinXisNaN = isnan(mMinX);
  bool MaxXisNaN = isnan(mMaxX);
  bool MinYisNaN = isnan(mMinY);
  bool MaxYisNaN = isnan(mMaxY);

  while (xIt < end)
    {
      const double xv = *xIt++;

      if (!isnan(xv))
        {
          if (xv < mMinX || MinXisNaN)
            {
              mMinX = xv;
              MinXisNaN = false;
            }

          if (xv > mMaxX || MaxXisNaN)
            {
              mMaxX = xv;
              MaxXisNaN = false;
            }
        }

      double yv1 = *yIt1++;
      double yv2 = *yIt2++;

      if (isnan(yv1) || isnan(yv2))
        {
          yv1 = isnan(yv1) ? yv2 : yv1;
          yv2 = yv1;
        }
      else if (yv1 > yv2)
        {
          double tmp = yv1;
          yv1 = yv2;
          yv2 = tmp;
        } // now: yv1 <= yv2

      if (!isnan(yv1))
        {
          if (yv1 < mMinY || MinYisNaN)
            {
              mMinY = yv1;
              MinYisNaN = false;
            }

          if (yv2 > mMaxY || MaxYisNaN)
            {
              mMaxY = yv2;
              MaxYisNaN = false;
            }
        }
    }

  if (isnan(mMinX + mMaxX + mMinY + mMaxY))
    return QwtDoubleRect(1.0, 1.0, -2.0, -2.0); // invalid

  // We need to avoid very small data ranges (absolute and relative)
  C_FLOAT64 minRange = fabs(mMinX + mMaxX) * 5.e-5 + std::numeric_limits< C_FLOAT64 >::min() * 100.0;

  if (mMaxX - mMinX < minRange)
    {
      mMinX = mMinX - minRange * 0.5;
      mMaxX = mMaxX + minRange * 0.5;
    }

  minRange = fabs(mMinY + mMaxY) * 5e-5 + std::numeric_limits< C_FLOAT64 >::min() * 100.0;

  if (mMaxY - mMinY < minRange)
    {
      mMinY = mMinY - minRange * 0.5;
      mMaxY = mMaxY + minRange * 0.5;
    }

  return QwtDoubleRect(mMinX, mMinY, mMaxX - mMinX, mMaxY - mMinY);
}

QwtData * CBandedGraphData::copy ( ) const

virtual

Definition at line 249 of file CopasiPlot.cpp.

References CBandedGraphData().

{
  CBandedGraphData * pCopy = new CBandedGraphData();

  *pCopy = *this;

  return pCopy;
}

CBandedGraphData & CBandedGraphData::operator= ( const CBandedGraphData &  rhs )

protected

Definition at line 409 of file CopasiPlot.cpp.

References mLastRectangle, mMaxSize, mMaxX, mMaxY, mMinX, mMinY, mpX, mpY1, mpY2, and mSize.

{
  mpX = rhs.mpX;
  mpY1 = rhs.mpY1;
  mpY2 = rhs.mpY2;
  mSize = rhs.mSize;
  mMaxSize = rhs.mMaxSize;
  mLastRectangle = rhs.mLastRectangle;
  mMinX = rhs.mMinX;
  mMaxX = rhs.mMaxX;
  mMinY = rhs.mMinY;
  mMaxY = rhs.mMaxY;

  return * this;
}

void CBandedGraphData::reallocated	(	const CVector< double > *	pX,
		const CVector< double > *	pY1,
		const CVector< double > *	pY2
	)

Definition at line 399 of file CopasiPlot.cpp.

References CVectorCore< CType >::array(), mMaxSize, mpX, mpY1, mpY2, mSize, and CVectorCore< CType >::size().

{
  mpX = pX->array();
  mpY1 = pY1->array();
  mpY2 = pY2->array();
  mMaxSize = pX->size();

  assert(mSize <= mMaxSize);
}

void CBandedGraphData::setSize

(

const size_t &

size

)

Definition at line 392 of file CopasiPlot.cpp.

References mMaxSize, mSize, and size().

{
  mSize = size;
  assert(mSize <= mMaxSize);
}

size_t CBandedGraphData::size ( ) const

virtual

Definition at line 259 of file CopasiPlot.cpp.

References mSize.

Referenced by setSize().

{return 2 * mSize;}

double CBandedGraphData::x ( size_t  i ) const

virtual

Definition at line 262 of file CopasiPlot.cpp.

References mpX, and mSize.

{
  // to make a polygon out of the two data curves
  // one curve goes in order, the other backwards
  if (i >= mSize)
    i = (2 * mSize - i - 1);

  return *(mpX + i);
}

double CBandedGraphData::y ( size_t  i ) const

virtual

Definition at line 272 of file CopasiPlot.cpp.

References mpY1, mpY2, and mSize.

{
  double ret;

  // to make a polygon out of the two data curves
  // one curve goes in order, the other backwards
  if (i < mSize)
    ret = *(mpY1 + i);
  else
    ret = *(mpY2 + (2 * mSize - i - 1));

  return ret;
}

double CBandedGraphData::y1

(

size_t

i

)

const

Definition at line 286 of file CopasiPlot.cpp.

References mpY1.

{
  return *(mpY1 + i);
}

double CBandedGraphData::y2

(

size_t

i

)

const

Definition at line 291 of file CopasiPlot.cpp.

References mpY2.

{
  return *(mpY2 + i);
}

Member Data Documentation

size_t CBandedGraphData::mLastRectangle

mutableprivate

Definition at line 114 of file CopasiPlot.h.

Referenced by boundingRect(), and operator=().

size_t CBandedGraphData::mMaxSize

private

Definition at line 112 of file CopasiPlot.h.

Referenced by CBandedGraphData(), operator=(), reallocated(), and setSize().

double CBandedGraphData::mMaxX

mutableprivate

Definition at line 116 of file CopasiPlot.h.

Referenced by boundingRect(), and operator=().

double CBandedGraphData::mMaxY

mutableprivate

Definition at line 118 of file CopasiPlot.h.

Referenced by boundingRect(), and operator=().

double CBandedGraphData::mMinX

mutableprivate

Definition at line 115 of file CopasiPlot.h.

Referenced by boundingRect(), and operator=().

double CBandedGraphData::mMinY

mutableprivate

Definition at line 117 of file CopasiPlot.h.

Referenced by boundingRect(), and operator=().

const double* CBandedGraphData::mpX

private

Definition at line 107 of file CopasiPlot.h.

Referenced by boundingRect(), operator=(), reallocated(), and x().

const double* CBandedGraphData::mpY1

private

Definition at line 108 of file CopasiPlot.h.

Referenced by boundingRect(), operator=(), reallocated(), y(), and y1().

const double* CBandedGraphData::mpY2

private

Definition at line 109 of file CopasiPlot.h.

Referenced by boundingRect(), operator=(), reallocated(), y(), and y2().

size_t CBandedGraphData::mSize

private

Definition at line 111 of file CopasiPlot.h.

Referenced by boundingRect(), CBandedGraphData(), operator=(), reallocated(), setSize(), size(), x(), and y().

---

The documentation for this class was generated from the following files:

• CopasiPlot.h
• CopasiPlot.cpp