Main page

---

Number.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 NUMBER_H
#define NUMBER_H

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

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



#define mcNUMBER_DECIMAL_POINT   wxT('.')



mcDEFINE_HELPER_CLASSES(mcNumber)

// defined later
extern mcNumber mcEmptyNumber;



class mcNumberHelpers : public mcExpElementHelpers
{
 mcDEFINE_REFERENCE_DATA(mcNumber, mcET_NUMBER);

#ifdef mcENABLE_DATA
protected:  // DATA variables

 mcRealValue mdata_n;

#endif



#ifdef mcENABLE_GUI
protected:  // GUI variables

 wxString mgui_strTrailer;

 int mgui_nCursorPos;

public:   // customizable variables

 static int sgui_nDigitToShow;

 static wxString sgui_strFloatingPoint;


public:  // utilities
  
 static bool gui_isDigit(int vk);

 static bool gui_isDecimalPoint(wxChar totest)
  { return sgui_strFloatingPoint.Find(totest) != wxNOT_FOUND; }

#endif



#ifdef mcENABLE_MATH
public:   // customizable variables

 static bool smath_bUseIntegersWhenPossible;

public:   // static utilities

 static mcNumber *smath_pOne;
 static mcNumber *smath_pTwo;
 static mcNumber *smath_pFour;
 static mcNumber *smath_pMinusOne;
 static mcNumber *smath_pZero;

 static bool math_isZero(const mcElement &);

#endif



public:

 mcNumberHelpers() {
  mdata_n = 0;      // zero by default
  //m_n.Set(0);

  mdata_bExpEnabled = TRUE;
  mdata_bSubEnabled = FALSE; // do not allow subscripts

  data_Init();
 }

 virtual ~mcNumberHelpers() {}

protected:

 void gui_Init() {
  mcExpElementHelpers::gui_Init();
  mgui_nCursorPos = 0;     // cursor is placed on first digit
 }




#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__

 wxString data_BaseDebug(long flags) const {

  wxString exp = data_Get().GetStr();
  wxString smart = data_Get().GetSmartStr();

  // choose shortest
  return wxT("mcNumber     ") + (exp.Len() > smart.Len() ? smart : exp) + wxT("\n");
 }

#endif

 void data_DeepCopy(const mcElementHelpers *p) {
  const mcNumberHelpers *n = (const mcNumberHelpers *)p;
  mdata_n = n->mdata_n;
  mgui_strTrailer = n->mgui_strTrailer;
  mcExpElementHelpers::data_DeepCopy(p);
 }

 bool data_isSameAs(const mcElementHelpers *p) const {
  if (!mcElementHelpers::data_isSameAs(p))
   return FALSE;

  const mcNumberHelpers *ed = (const mcNumberHelpers *)p;
  if (mdata_n != ed->mdata_n) return FALSE;
  return TRUE;
 }

 bool data_isAllowedBefore(mcElementType type) const {
  if (type == mcET_NUMBER)
   return FALSE;
  return TRUE;
 }

 bool data_isAllowedAfter(mcElementType type) const {
  // mcET_PARENTHESIS is a special case: when it's a left
  // bracket, then there must be *no* operators between it
  // and other elements: (*4x) is invalid !!
  if (type == mcET_NUMBER || type == mcET_BRACKET || 
   type == mcET_FUNCTION || type == mcET_SYMBOL || 
   type == mcET_RADICAL || type == mcET_FRACTION)
   return FALSE;
  return TRUE;
 }

 void data_Set(const mcRealValue &d)    { mdata_n = d; }
 mcRealValue data_Get() const     { return mdata_n; }

#endif  // mcENABLE_DATA





#ifdef mcENABLE_GUI
public:

 void gui_Set(const wxString &toset);
 wxString gui_GetStr() const
  { return data_Get().GetSmartStr()+mgui_strTrailer; }



 bool gui_isBeginKey(const mcKey &ev) const;
 bool gui_isBaseEndKey(const mcKey &ev) const;

 bool gui_DrawAsActiveOverBase() const { return TRUE; }
 
 mcInsertRes gui_BaseInsert(const mcElement &, mcElement *);
 mcInputRes gui_BaseInput(const mcKey &key, mcElement *pnew);
 mcMoveCursorRes gui_BaseMoveCursor(mcMoveCursorFlag flag, long modifiers);
 int gui_DrawBase(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const; 
 int gui_BaseMoveCursorUsingPoint(wxDC &, const wxPoint &);
 int gui_GetBaseRelCursorPos(wxDC &dc, wxPoint *pt) const;
 void gui_GetBaseCursorPos(mcCursorPos &) const;

 void gui_SetBaseCursorPos(const mcCursorPos &);
 void gui_DoRecalcBaseSize();
 void gui_EditBase();

 bool gui_Split(mcElement *);
 bool gui_MergeWith(const mcElement &);

 bool gui_isSplittable() const  { return TRUE; }


#endif  // mcENABLE_GUI





#ifdef mcENABLE_MATH
public:

 void math_Abs()       { data_Set(data_Get().abs()); }
 bool math_isValid() const    { return data_Get().isValid(); }

 bool math_GetNumDen(mcIntegerValue &num, mcIntegerValue &den);
 mcFraction math_TransformInFraction();

 void math_RaiseBaseTo(mcRealValue n);
 virtual void math_RaiseTo(const mcIntegerValue &n);




 bool math_CanBeAddedWith(const mcElement &p) const;
 bool math_CanBeMultWith(const mcElement &p) const;
 bool math_CanBeDivBy(const mcElement &p) const;

 mcBasicOpRes math_Add(const mcElement &, mcElement *, bool add);

 mcBasicOpRes math_MultiplyBaseOnlyBy(const mcElement &, mcElement *);
 mcBasicOpRes math_DivideBaseOnlyBy(const mcElement &, mcElement *);
 mcBasicOpRes math_MultiplyBaseBy(const mcElement &, mcElement *);
 mcBasicOpRes math_DivideBaseBy(const mcElement &, mcElement *) 
  { return mcBOR_REMOVE_OPERAND; }

 mcRealValue math_GetBaseLenght() const  { return data_Get().GetNumOfDigits(); }
 mcRealValue math_EvaluateBase() const  { return data_Get(); }
 int math_GetOrderPos() const    { return 0; }
 //mcBasicOpRes math_MakeReciprocal(mcElement *);
 
 mcMathType math_GetBaseMathType() const 
  { return mcMathType(mcMTL1_POLYNOMIAL, mcMTL2_ALGEBRAIC, mcMTL3_CONSTANT); }

 mcBasicOpRes math_MakeReciprocal(mcElement *);

 mcExpSimRes math_ExpandBase(long flags, mcElement *newelem);
 mcExpSimRes math_SimplifyBase(long flags, mcElement *newelem);
 mcExpSimRes math_SimplifyBaseExp(long flags, mcElement *pnew);

 //bool hasSameContentOf(const mcElement &p) const;
 bool math_CompareThisOnly(const mcElement &p, long flags) const;

 mcMonomial math_GetBaseLCM(const mcElement &p) const;
 mcMonomial math_GetGCD(const mcElement &p) const;


#endif  // mcENABLE_MATH




#ifdef mcENABLE_IO
public:

 bool io_isBeginTag(const wxXml2Node &tag) const {
  if (tag.GetName() == wxT("mn"))
   return TRUE;
  return FALSE;
 }

 bool io_isBeginChar(const wxString &str) const;

 // MATH ML export functions
 wxXml2Node io_GetBaseMathML(bool bGetPresentation) const;
 wxString io_GetBaseInlinedExpr() const;

 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);
 bool io_ImportBaseInlinedExpr(const wxString &, int *count, wxString &pErr);

#endif  // mcENABLE_IO
};




class mcNumber : public mcExpElement
{
 mcDEFINE_MAIN_CLASS(Number, mcExpElement);

public:

 mcNumber(const mcRealValue &n)
  { data_SetRefData(new mcNumberHelpers); hlp()->data_Set(n); }

 bool data_isValidContainerFor(mcElementType t) const
  { return t == mcET_NUMBER; }

 mcWRAPPER void data_Set(const mcRealValue &d)   { hlp()->data_Set(d); }
 mcWRAPPER mcRealValue data_Get() const     { return hlp()->data_Get(); }

 mcWRAPPER void math_Abs()
  { hlp()->math_Abs(); }

 mcWRAPPER bool math_isValid() const
  { return hlp()->math_isValid(); }

 mcWRAPPER bool math_GetNumDen(mcIntegerValue &num, mcIntegerValue &den)
  { return hlp()->math_GetNumDen(num, den); }

 // this needs to be in the source file
 mcFraction math_TransformInFraction();
};

#endif // NUMBER_H

---

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

[ Top ]