Main page

---

Range.h

Go to the documentation of this file.

// MathCore = a WYSIWYG equation editor + a powerful math engine     //
// Copyright (C) 2003 by Francesco Montorsi                          //
//                                                                   //
// This library is free software; you can redistribute it and/or     //
// modify it under the terms of the GNU Lesser General Public        //
// License as published by the Free Software Foundation; either      //
// version 2.1 of the License, or (at your option) any later         //
// version.                                                          //
//                                                                   //
// This library is distributed in the hope that it will be useful,   //
// but WITHOUT ANY WARRANTY; without even the implied warranty of    //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the      //
// GNU Lesser General Public License for more details.               //
//                                                                   //
// You should have received a copy of the GNU Lesser General Public  //
// License along with this program; if not, write to the Free        //
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,   //
// MA 02111-1307, USA.                                               //
//                                                                   //
// For any comment, suggestion or feature request, please contact    //
// the administrator of the project at frm@users.sourceforge.net     //
//                                                                   //



#ifndef RANGE_H
#define RANGE_H

// optimization for GCC compiler
#ifdef __GNUG__
//#pragma interface "Range.h"
#endif

// required includes
#include "mc/Polynomial.h"


class mcRange : public mcMathHelper
{
protected:

 mcPolynomial m_pUpper;
 
 mcPolynomial m_pLower;
 
 mcBoundaryMode m_nBounds;
 
 mcSet m_nSet;

public:  // static public objects

 static mcRange *pN;  
 static mcRange *pZ;  
 static mcRange *pR;  
 static mcRange *pC;  
 
 static mcRange *pEmpty;  
 
public:
 
 mcRange(const mcRealValue &l = *mcIntegerValue::pZero,
  const mcRealValue &u = *mcIntegerValue::pOne,
  mcSet s = mcSET_R,
  mcBoundaryMode m = mcBM_INCLUDE_BOTH)
 { math_Set(l, u); math_Set(s, m); }

 mcRange(const mcPolynomial &l,
  const mcPolynomial &u,
  mcSet s = mcSET_R,
  mcBoundaryMode m = mcBM_INCLUDE_BOTH)
 { math_Set(l, u); math_Set(s, m); }
 
 virtual ~mcRange();


 mcRange *data_Clone() const 
  { return new mcRange(m_pLower, m_pUpper, m_nSet, m_nBounds); }
 
 void math_Order();

 bool math_isFinite() const;


 void math_Set(const mcPolynomial &l = mcEmptyElement, 
   const mcPolynomial &u = mcEmptyElement);
 void math_Set(const mcRealValue &l = *mcRealValue::pNAN, 
   const mcRealValue &u = *mcRealValue::pNAN);
 void math_Set(mcSet newset, mcBoundaryMode m) 
  { m_nSet=newset; m_nBounds=m; }

 mcSet math_GetSet() const       { return m_nSet; }
 mcBoundaryMode math_GetBoundaryMode() const   { return m_nBounds; }
 const mcPolynomial &math_GetUpperLimit() const  { return m_pUpper; }
 const mcPolynomial &math_GetLowerLimit() const  { return m_pLower; }
 
 mcRealValue math_GetUpperLimitValue() const;
 mcRealValue math_GetLowerLimitValue() const;

 wxString io_GetInlinedExpr() const;
};


class mcExtRange : public mcAbstractArray
{
protected:
 void data_Delete(int n) 
  { delete data_GetRange(n); }

public:  // static public objects

 static mcExtRange *pN;  
 static mcExtRange *pZ;  
 static mcExtRange *pR;  
 static mcExtRange *pC;  
 
 static mcExtRange *pEmpty;  
 
public:
 mcExtRange() {}
 mcExtRange(const mcRange &r) { data_Add(r); }
 mcExtRange(const mcExtRange &r) { data_DeepCopy(r); }
 virtual ~mcExtRange() { data_Clear(); }
 

 void data_DeepCopy(const mcExtRange &r) {
  data_Clear();
  for (int i=0; i < r.data_GetCount(); i++)
   data_Add(*r.data_GetRange(i));
 }

 void data_Add(const mcRange &r)   
  { mcAbstractArray::data_Add(r.data_Clone()); }

 void math_Intersect(const mcRange &r);
 void math_Union(const mcRange &r);

 bool math_isFinite() const;

 mcExtRange *data_Clone() const
  { return new mcExtRange(*this); }

 mcRange *data_GetRange(int n)      { return (mcRange *)data_GetItem(n); }
 const mcRange *data_GetRange(int n) const   { return (mcRange *)data_GetItem(n); }
};

#endif  // RANGE_H

---

Documentation generated with Doxygen on Sun Feb 6 17:10:48 2005 Visit MathStudio home page for more info

[ Top ]