Main page

---

Fraction.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 mcFRACTION_H
#define mcFRACTION_H

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

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


mcDEFINE_HELPER_CLASSES(mcFraction)







class mcFractionHelpers : public mcElementHelpers
{
 mcDEFINE_REFERENCE_DATA(mcFraction, mcET_FRACTION);

#ifdef mcENABLE_DATA
protected:  // DATA variables

 mcPolynomial mdata_eNum;
 
 mcPolynomial mdata_eDen;

#endif



#ifdef mcENABLE_GUI
protected:  // GUI variables

 int mgui_nCursorPos;

 // mgui_nCursorPos can assume the following values:
#define mcFRACTION_LEFTMOST     1 
#define mcFRACTION_INSIDENUM     2 
#define mcFRACTION_INSIDEDEN     3 
#define mcFRACTION_RIGHTMOST     4 

public:     // customizable variables

 static mcKey *sgui_pNewFraction;

 static int sgui_nSpaceAboveBelow;

 static int sgui_nSpaceBetween;

 static int sgui_nAdditionalWidth;

 static int sgui_nAdditionalSpace;

#endif  // mcENABLE_GUI



public:
 mcFractionHelpers() { data_Init(); }
 virtual ~mcFractionHelpers() {}

protected:

 void gui_Init() {
  mcElementHelpers::gui_Init();
  mgui_nCursorPos = mcFRACTION_INSIDENUM;
 } 




#ifdef mcENABLE_DATA
public:

#ifdef __MCDEBUG__
 wxString data_Debug(long flags) const;
 void data_Check() const;
#endif

 int data_GetChildrenCount() const {
  // the num & den are *always* present because they are created
  // in mcFractionData contructor...
  return mcElementHelpers::data_GetChildrenCount()+2;
 }

 const mcElement &data_GetConstChild(int n) const {
  mcRETURN_ELEMENT_CHILD(n, mcElementHelpers);
  if (n == 0)
   return data_GetNum();
  if (n == 1)
   return data_GetDen();
  return mcEmptyElement;
 }
 
 void data_SetChild(int n, const mcElement &newchild) {
  mcSET_ELEMENT_CHILD(n, mcElementHelpers, newchild);
  mcASSERT(newchild.data_GetType() == mcET_POLYNOMIAL, wxT("Invalid new child"));
  mcPolynomial p(newchild);

  if (n == 0) data_SetNum(p);
  if (n == 1) data_SetDen(p);
  }

 void data_DeepCopy(const mcElementHelpers *p) {
  const mcFractionHelpers *f = (const mcFractionHelpers *)p;
  mdata_eNum.data_DeepCopy(f->mdata_eNum);
  mdata_eDen.data_DeepCopy(f->mdata_eDen);
  mgui_nCursorPos = f->mgui_nCursorPos;
  mcElementHelpers::data_DeepCopy(p);
 }

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

  const mcFractionHelpers *fd = (const mcFractionHelpers *)p;
  if (mdata_eNum != fd->mdata_eNum) return FALSE;
  if (mdata_eDen != fd->mdata_eDen) return FALSE;
  return TRUE;
 }

 void data_SetDen(const mcPolynomial &p) {
  mdata_eDen = p;
  mdata_eDen.data_Check();
 }

 void data_SetNum(const mcPolynomial &p) {
  mdata_eNum = p;
  mdata_eNum.data_Check();
 }

 virtual void data_AddElements(bool bNum, mcElement *p, int num, 
  int pos = -1, bool bOverwrite = FALSE, bool bForceCopy = FALSE);

 mcPolynomial &data_GetNum()       { return mdata_eNum; }
 mcPolynomial &data_GetDen()       { return mdata_eDen; }
 const mcPolynomial &data_GetNum() const    { return mdata_eNum; }
 const mcPolynomial &data_GetDen() const    { return mdata_eDen; }

/* mcPolynomialHelpers *data_GetNumHlp()        { return mdata_eNum.hlp(); }
 mcPolynomialHelpers *data_GetDenHlp()        { return mdata_eDen.hlp(); }
 const mcPolynomialHelpers *data_GetNumHlp() const    { return mdata_eNum.hlp(); }
 const mcPolynomialHelpers *data_GetDenHlp() const    { return mdata_eDen.hlp(); }
*/
#endif  // mcENABLE_DATA





#ifdef mcENABLE_GUI
public:


 wxPoint gui_GetNumPos() const;
 wxPoint gui_GetDenPos() const;

 void gui_SetCursorOnDen(mcCursorPos cp = mcCP_END) {
  mgui_nCursorPos = mcFRACTION_INSIDEDEN;
  data_GetDen().gui_SetCursorPos(cp);
 }

 void gui_SetCursorOnNum(mcCursorPos cp = mcCP_END) {
  mgui_nCursorPos = mcFRACTION_INSIDENUM;
  data_GetNum().gui_SetCursorPos(cp);
 }






 void gui_UpdateExpDepth() {
  data_GetNum().gui_SetAtSameLevelOf(this);
  data_GetDen().gui_SetAtSameLevelOf(this);
  mcElementHelpers::gui_UpdateExpDepth();
 }

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

 mcInputRes gui_Input(const mcKey &ev, mcElement *newelem);
 mcInsertRes gui_Insert(const mcElement &, mcElement *);
 mcMoveCursorRes gui_MoveCursor(mcMoveCursorFlag flag, long modifiers);
 void gui_GetCursorPos(mcCursorPos &) const;
 int gui_MoveCursorUsingPoint(wxDC &dc, const wxPoint &p);
 int gui_Draw(wxDC &dc, int x, int y, long flags, const wxPoint &pt) const;
 int gui_GetRelCursorPos(wxDC &dc, wxPoint *pt) const;
 int gui_GetYAnchor() const;

 void gui_SetCursorPos(const mcCursorPos &);
 void gui_OnSelect(wxDC &dc, wxRect &rc);
 void gui_DoRecalcSize();

 mcElement gui_GetSelection() const;
 void gui_DeleteSelection();

 // gui_DeSelect(), gui_SelectAll(), gui_isAllSelected() are implemented in mcElement


#endif  // mcENABLE_GUI





#ifdef mcENABLE_MATH
protected:

 mcExpSimRes math_SimplifyFactors(long flags, mcElement *newelem);

public:

 void math_Flip();




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

 virtual mcBasicOpRes math_Add(const mcElement &, mcElement *p, bool add); 
 virtual mcBasicOpRes math_MultiplyBy(const mcElement &, mcElement *p);
 virtual mcBasicOpRes math_DivideBy(const mcElement &, mcElement *p);

 mcRealValue math_GetLenght() const    { return 1.5; }
 int math_GetOrderPos() const     { return 1; }

 mcMathType math_GetMathType() const;
 mcBasicOpRes math_MakeReciprocal(mcElement *)
  { math_Flip(); return mcBOR_REMOVE_OPERAND; }

 mcExpSimRes math_Simplify(long flags, mcElement *newelem);
 mcExpSimRes math_Expand(long flags, mcElement *newelem);

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

 mcRealValue math_Evaluate() const;
 void math_SetExp(const mcPolynomial &p); 
 mcBasicOpRes math_RaiseTo(const mcPolynomial &p);

 //mcPolynomial &&math_GetFactors() const;
 mcMonomial math_GetLCM(const mcElement &) const;
 mcMonomial math_GetGCD(const mcElement &) const;


#endif  // mcENABLE_MATH



#ifdef mcENABLE_IO
public:

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

 bool io_isBeginChar(const wxString &str) const {
  return FALSE;
 }

 
 void io_Set(const wxString &num, const wxString &den) {
  io_SetNum(num);
  io_SetDen(den);
 }

 void io_SetNum(const wxString &num);
 void io_SetDen(const wxString &den);


 // MATH ML export functions
 wxXml2Node io_GetMathML(bool bGetPresentation) const;
 wxString io_GetInlinedExpr() const;

 bool io_CheckBracketNeed(const mcPolynomial &p, const wxString &exp) const;
 bool io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr);
 bool io_ImportInlinedExpr(const wxString &str, int *count, wxString &pErr);

#endif  // mcENABLE_IO
};


class mcFraction : public mcElement
{
 mcDEFINE_MAIN_CLASS(Fraction, mcElement);

public:

 mcFraction(const mcNumber &n, const mcNumber &d)
 { data_SetRefData(new mcFractionHelpers()); data_SetNum(mcPolynomial(n)); data_SetDen(mcPolynomial(d)); }

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

 mcWRAPPER void data_SetDen(const mcPolynomial &p)
  { hlp()->data_SetDen(p); }
 mcWRAPPER void data_SetNum(const mcPolynomial &p)
  { hlp()->data_SetNum(p); }

 mcWRAPPER void data_AddElements(bool bNum, mcElement *p, int num, 
  int pos = -1, bool bOverwrite = FALSE, bool bForceCopy = FALSE)
  { hlp()->data_AddElements(bNum, p, num, pos, bOverwrite, bForceCopy); }

 mcWRAPPER mcPolynomial &data_GetNum()      { return hlp()->data_GetNum(); }
 mcWRAPPER mcPolynomial &data_GetDen()      { return hlp()->data_GetDen(); }



 mcWRAPPER wxPoint gui_GetNumPos() const
  { return hlp()->gui_GetNumPos(); }
 mcWRAPPER wxPoint gui_GetDenPos() const
  { return hlp()->gui_GetDenPos(); }

 mcWRAPPER void gui_SetCursorOnDen(mcCursorPos cp = mcCP_END)
  { hlp()->gui_SetCursorOnDen(cp); }
 mcWRAPPER void gui_SetCursorOnNum(mcCursorPos cp = mcCP_END)
  { hlp()->gui_SetCursorOnNum(cp); }


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


#endif // mcFRACTION_H

---

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

[ Top ]