Main page

---

MathHelpers.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 MATHHELPERS_H
#define MATHHELPERS_H

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



//  Includes
// ----------

#include <wx/dynarray.h> // for wxSymbolArray
#include <wx/event.h>  // for wxKeyEvent
#include <wx/font.h>
#include <wx/colour.h>
#include <wx/dc.h>

#include "mc/MathUtils.h"
#include "mc/MathTypes.h"
#include "mc/Value.h"

class mcElement;


typedef void  mcAbstractItem;


class mcAbstractArray
{
 wxArrayPtrVoid m_arr;

protected:

 virtual void data_Delete(int n) = 0;

 virtual mcAbstractItem *data_GetCopyOf(int) const { return NULL; }

 virtual void data_OnArrayChange() {}

public:

 mcAbstractArray() {}

 virtual ~mcAbstractArray() {}

#ifdef __MCDEBUG__
 virtual void data_Check() const;
#else
 inline void data_Check() const {}
#endif




 void data_Add(mcAbstractItem *pointer);

 void data_Insert(mcAbstractItem *pointer, int n);

 void data_SetItem(mcAbstractItem *pointer, int n);

 void data_RemoveAt(int idx, int count = 1);

 void data_Remove(const mcAbstractItem *p);

 mcAbstractItem *data_Detach(int idx);

 void data_Clear();

 void data_DeepCopy(const mcAbstractArray &arr);

 mcAbstractItem *data_GetItem(int idx)    { return m_arr.Item(idx); }

 const mcAbstractItem *data_GetItem(int idx) const { return m_arr.Item(idx); }




 
 bool data_isEmpty() const       { return m_arr.IsEmpty(); }

 int data_GetCount() const       { return m_arr.GetCount(); }

 int data_Find(const mcAbstractItem *pointer) const;

};



class mcGUIHelper
{
public:
 mcGUIHelper() {}
 virtual ~mcGUIHelper() {}
};



class mcMathHelper
{
public:
 mcMathHelper() {}
 virtual ~mcMathHelper() {}
};



class mcDataHelper
{
public:
 mcDataHelper() {}
 virtual ~mcDataHelper() {}
};




#define mcKEY_MAX_COMBINATIONS      2

class mcKeyEntry : public mcGUIHelper
{
protected:
 
#define SHIFT_KEY  1
#define CTRL_KEY  2
#define META_KEY  4
#define ALT_KEY   8 

 

 int m_nFlags;
 
 int m_nKeyCode;
 
 bool m_bSpecial;
 
 
protected:
 
 void InitFlags(const wxString &str) {
  wxString s = GetModifiersFrom(str);
  m_nFlags = 0;
  
  m_nFlags |= (s.Contains(wxT("c")) ? CTRL_KEY : 0);
  m_nFlags |= (s.Contains(wxT("m")) ? META_KEY : 0);
  m_nFlags |= (s.Contains(wxT("a")) ? ALT_KEY : 0);
  m_nFlags |= (s.Contains(wxT("s")) ? SHIFT_KEY : 0);
  m_bSpecial = s.Contains(wxT("x"));
 }
 
 void InitKeyCode(const wxString &str) {
  long m;
  wxString num = str.Right(str.Len()-GetModifiersFrom(str).Len());
  if (num.GetChar(0) == wxT('+') || num.GetChar(0) == wxT('-'))
   num.Remove(0, 1);  // remove first character
  num.ToLong(&m);
  m_nKeyCode = (int)m;
 }
 
 wxString GetModifiersFrom(const wxString &def) {
  
  // return everything before first '+'
  wxString modifiers = def.BeforeFirst(wxT('+'));
  modifiers.MakeLower();
  return modifiers;
 }
 
public:
 
 mcKeyEntry() {
  Reset();
 }
 
 mcKeyEntry(const wxString &str, long keycode) {
  Reset();
  InitFlags(str);
  m_nKeyCode = keycode;
 }
 
 mcKeyEntry(const wxString &str) {
  Reset();
  InitFlags(str);
  InitKeyCode(str);
 }
 
 mcKeyEntry( const wxKeyEvent &keyEvent )
 {
  Reset();
  if ( keyEvent.m_altDown )
   m_nFlags += ALT_KEY;
  if ( keyEvent.m_shiftDown )
   m_nFlags += SHIFT_KEY;
  if ( keyEvent.m_controlDown )
   m_nFlags += CTRL_KEY;
  if ( keyEvent.m_metaDown )
   m_nFlags += META_KEY;
  m_nKeyCode = keyEvent.m_keyCode;
 }

 virtual ~mcKeyEntry() {}
 
 
 void Reset() {
  m_nKeyCode = m_nFlags = 0;
  m_bSpecial = FALSE;
 }
 
 wxString Encode() const {
  wxString str;
  
  // adds the (eventually) present modifiers
  if (m_nFlags & CTRL_KEY) str += wxT("c");
  if (m_nFlags & SHIFT_KEY) str += wxT("s");
  if (m_nFlags & META_KEY) str += wxT("m");
  if (m_nFlags & ALT_KEY) str += wxT("a");
  
  // save main keycode
  str.Printf(wxT("%s+%d"), (const wxChar *)str, m_nKeyCode);
  
  // finished...
  return str;
 }
 
 bool MatchKey(const mcKeyEntry &ke) const {
  bool bTheSame = TRUE;
  
  // if one of this pair of values are different,
  // the two key objects represents different key
  // combinations
  bTheSame &= (m_nFlags == ke.m_nFlags);
  bTheSame &= (m_nKeyCode == ke.m_nKeyCode);
  bTheSame &= (m_bSpecial == ke.m_bSpecial);
  
  return bTheSame;
 }
 
 bool MatchKey(const wxKeyEvent &ke) const {
  bool bTheSame = TRUE;
  
  // if one of this pair of values are different,
  // the two key objects represents different key
  // combinations
  bTheSame &= (ke.ControlDown() == ((m_nFlags & CTRL_KEY) != 0));
  bTheSame &= (ke.ShiftDown() == ((m_nFlags & SHIFT_KEY) != 0));
  bTheSame &= (ke.MetaDown() == ((m_nFlags & META_KEY) != 0));
  bTheSame &= (ke.AltDown() == ((m_nFlags & ALT_KEY) != 0));
  bTheSame &= (ke.GetKeyCode() == m_nKeyCode);
  
  return bTheSame;
 }
 
 wxKeyEvent GetEvent() {
  wxKeyEvent res;
  
  // copy attributes ( the '!= 0' at the end is required to avoid warnings)
  res.m_altDown = (m_nFlags & ALT_KEY) != 0;
  res.m_shiftDown = (m_nFlags & SHIFT_KEY) != 0;
  res.m_controlDown = (m_nFlags & CTRL_KEY) != 0;
  res.m_metaDown = (m_nFlags & META_KEY) != 0;
  res.m_keyCode = m_nKeyCode;
  
  // return result
  return res;
 }
 
 wxChar GetKeyCode() {
  if ((m_nKeyCode >= 0 && m_nKeyCode <= 255) || m_bSpecial)
   return (wxChar)m_nKeyCode;
  return 0;
 }
 
 int GetModifiers() {
  return m_nFlags;
 }
 
 void SetAsSpecialKey() {
  m_bSpecial = TRUE;
 }
 
 bool isSpecialKey() {
  return m_bSpecial;
 }
};




class mcKey : public mcGUIHelper
{
protected:
 
 void Reset() {
  for (int i=0; i < mcKEY_MAX_COMBINATIONS; i++)
   m_pMatch[i] = NULL;
  m_strDescription = wxT("");
 }

public:  // these variables are public so we can avoid a lot of
   // getters/setters which would provide full access anyway
 
 mcKeyEntry *m_pMatch[mcKEY_MAX_COMBINATIONS];
 
 wxString m_strDescription;
 
public:  // special routines

 void DeepCopy( const mcKey& other ) {

  // avoid to copy itself
  if ( &other == this )
   return;

  Cleanup();  // deallocates actual content

  for (int i=0; i < mcKEY_MAX_COMBINATIONS; i++)
   if (other.m_pMatch[i])
    m_pMatch[i] = new mcKeyEntry(*other.m_pMatch[i]);
 }
 
 void Cleanup() {
  for (int i=0; i < mcKEY_MAX_COMBINATIONS; i++)
   mcSAFE_DELETE(m_pMatch[i]);
 }

 
public:
 
 mcKey(const wxString &def) {
  wxString str = def;
  
  // create the mcKeyEntries and init them
  for (int i=0; i < mcKEY_MAX_COMBINATIONS; i++) {
   m_pMatch[i] = new mcKeyEntry(str.BeforeFirst(wxT(';')));
   str = str.AfterFirst(wxT(';'));
  }
 }
 
 mcKey(const wxChar c, bool bSpecial = FALSE) {
  Reset();
  m_pMatch[0] = new mcKeyEntry(wxEmptyString, c);
  if (bSpecial) m_pMatch[0]->SetAsSpecialKey();
 }
 
 mcKey(const wxKeyEvent &key, bool bSpecial = FALSE) {
  Reset();
  m_pMatch[0] = new mcKeyEntry(key);
  if (bSpecial) m_pMatch[0]->SetAsSpecialKey();
 }
 
 mcKey(const mcKey &other) {
  Reset();
  DeepCopy( other );
 }
 
 mcKey() {
  Reset();
 }
 
 mcKey& operator = ( const mcKey& other )  {
  DeepCopy( other );
  return *this;
 }
 
 virtual ~mcKey() {
  Cleanup();
 }

 
 /* void Decode(const wxString &str) {
 wxString match;
 
  // load each key entry enconding string using semicolon as tokenizer
  for (int c=0; c < mcKEY_MAX_COMBINATIONS; c++) {
  match = str.Left(str.math_Find(wxT(";")));
  kMatch[c]->Decode(match);
  }
  }
  
   wxString Encode() const {
   wxString str;
   
    // divide each key entry enconding string with a semicolon
    for (int c=0; c < mcKEY_MAX_COMBINATIONS; c++)
    str += kMatch[c]->Encode() + wxT(";");
    
  return str;
        }
 */
 bool MatchKey(const wxKeyEvent &ke) const {
  bool bTheSame = FALSE;
  for (int c=0; c < mcKEY_MAX_COMBINATIONS; c++)
   if (m_pMatch[c])
    bTheSame |= m_pMatch[c]->MatchKey(ke);
   return bTheSame;
 }
 
 bool MatchKey(const mcKey &ke) const {
  bool bTheSame = FALSE;
  for (int c=0; c < mcKEY_MAX_COMBINATIONS; c++)
   for (int d=0; d < mcKEY_MAX_COMBINATIONS; d++)
    if (m_pMatch[c] && ke.m_pMatch[d])
     bTheSame |= m_pMatch[c]->MatchKey(*ke.m_pMatch[d]);
                return bTheSame;
 }
 /*
 bool operator== (const mcKey &key) const {
 return MatchKey(key);
        }*/
 
 bool isSpecialKey(int n = 0) const {
  return m_pMatch[n]->isSpecialKey();
 }
 
 void SetAsSpecialKey(int n = 0) {
  m_pMatch[n]->SetAsSpecialKey();
 }
 
 wxKeyEvent GetEvent(int n = 0) const {
  return m_pMatch[n]->GetEvent();
 }
 
 wxChar GetKeyCode(int n = 0) const {
  return m_pMatch[n]->GetKeyCode();
 }
 
 int GetModifiers(int n = 0) const {
  return m_pMatch[n]->GetModifiers();
 }
};





class mcMathType : public mcMathHelper
{
public:  // public to avoid a lot of getters/setters
 
 mcMathTypeLevel1 m_tMath1;
 mcMathTypeLevel2 m_tMath2;
 mcMathTypeLevel3 m_tMath3;

 long m_tMath4;

public:

 mcMathType(mcMathTypeLevel1 t1 = mcMTL1_NOT_RECOGNIZED, 
     mcMathTypeLevel2 t2 = mcMTL2_NOT_RECOGNIZED, 
     mcMathTypeLevel3 t3 = mcMTL3_NOT_RECOGNIZED, 
        long t4 = mcMTL4_NOT_RECOGNIZED) :
      m_tMath1(t1), m_tMath2(t2), m_tMath3(t3), m_tMath4(t4) {}

 virtual ~mcMathType() {}

 wxString io_GetDescString() const;

 mcMathType math_MultiplyBy(const mcMathType &);
 mcMathType math_Add(const mcMathType &);
 mcMathType math_DivideBy(const mcMathType &);
 
 mcMathType math_RaiseTo(const mcMathType &);

 mcMathType math_ApplyOp(mcElementType optype, const mcMathType &);
};


class mcMathSystemType : public mcMathHelper
{
public:
 mcMathSystemTypeLevel1 m_tMath1;

public:

 mcMathSystemType(mcMathSystemTypeLevel1 t1 = mcMSTL1_NOT_RECOGNIZED) :
      m_tMath1(t1) {}
 virtual ~mcMathSystemType() {}

 wxString io_GetDescString(int neq) const;

 mcMathSystemType math_CombineWith(const mcMathSystemType &);
};


#define mcSYM_PARAMETER   0  
#define mcSYM_CONSTANT   1  
#define mcSYM_UNKNOWN    2  
#define mcSYM_UNREGISTERED  3  

#define mcSYM_NOTSET   -1  
#define mcSYM_NOTFOUND   -1  

// this will be defined later
class mcSymbol;
class mcSymbolHelpers;
class mcSymbolArray;
class mcExtRange;

class mcSymbolProperties : public mcMathHelper
{
 friend class mcSymbolArray;

protected:

 wxString m_strInlinedSymbol;
 
 wxArrayLong m_arrLinkedSymbol;

public:   // to avoid a LOT of getters/setters
    // (all members must be modifiable)

 int m_nSymbolType;

 wxFontEncoding m_fEncoding;

 wxString m_strSymbol;

 wxString m_strSubscript;

public:   // math properties

 mcRealValue m_fValue;
 
 mcExtRange *m_pDomain;

 bool m_bEvaluating;
 

public:

 mcSymbolProperties(int symtype = mcSYM_NOTSET, 
      const wxString &name = wxEmptyString,
      wxFontEncoding encoding = wxFONTENCODING_DEFAULT,
      const mcRealValue &value = 0.0, 
      const wxString &inlinedsym = wxEmptyString, 
      const wxString &subscript = wxEmptyString,
            mcExtRange *domain = NULL,
      bool evaluating = FALSE);

 virtual ~mcSymbolProperties();


 mcSymbolProperties *data_Clone() const {
  mcSymbolProperties *copy = new mcSymbolProperties(m_nSymbolType, m_strSymbol, 
   m_fEncoding, m_fValue, m_strInlinedSymbol, m_strSubscript, m_pDomain,
   m_bEvaluating);

  return copy;
 }

 wxString io_GetInlinedSym() const 
  { return m_strInlinedSymbol.IsEmpty() ? m_strSymbol : m_strInlinedSymbol; }
 wxString io_GetInlinedExpr() const
  { return io_GetInlinedSym(); }


 void data_Check() const {
  bool valid = TRUE;
  
  // check that data is correctly init
  valid &= !m_strSymbol.IsEmpty();
  valid &= (m_nSymbolType != mcSYM_NOTSET);
  if (data_isConstant()) valid &= (m_fValue != *mcRealValue::pNAN);
  
  mcASSERT(valid, wxT("This symbol is damaged !!!"));
  }

 int math_FindDuplicate(const mcSymbolArray *tosearch, int occ) const;





 void data_Link(const mcSymbolHelpers *p)  { m_arrLinkedSymbol.Add((long)p); }
 void data_Unlink(const mcSymbolHelpers *p)  { m_arrLinkedSymbol.Remove((long)p); }

 int data_GetLinkedSymCount() const    { return m_arrLinkedSymbol.GetCount(); }
 mcSymbolHelpers *data_GetLinkedSym(int n) const { return (mcSymbolHelpers*)m_arrLinkedSymbol.Item(n); } 

 const mcSymbolHelpers *data_GetSafeLinkedSym() const
 { mcASSERT(data_GetLinkedSym(0) != NULL, wxT("Invalid safe index ?"));
   return (const mcSymbolHelpers *)data_GetLinkedSym(0); }




 bool data_isRegistered() const { return m_nSymbolType != mcSYM_UNREGISTERED; }
 bool data_isParameter() const { return m_nSymbolType == mcSYM_PARAMETER; }
 bool data_isUnknown() const  { return m_nSymbolType == mcSYM_UNKNOWN; }
 bool data_isConstant() const { return m_nSymbolType == mcSYM_CONSTANT; }
 bool data_isUnlinked() const { return m_arrLinkedSymbol.IsEmpty(); }
 bool data_isSameAs(const mcSymbolProperties &s) const;

 bool math_isBeingEvaluated() const
  { return m_bEvaluating; }

};




#define mcMAX_SYMBOL_ARRAY_NUM     5

// flags used by mcSymbolArray::math_Find function.
#define mcSYMFIND_MATCH_NAME     1
#define mcSYMFIND_MATCH_ENCODING    2
#define mcSYMFIND_MATCH_INLINED     4
#define mcSYMFIND_MATCH_SUBSCRIPT    8
#define mcSYMFIND_MATCH_VALUE     16

#define mcSYMFIND_MATCH_ALL  (mcSYMFIND_MATCH_NAME | mcSYMFIND_MATCH_ENCODING | \
        mcSYMFIND_MATCH_INLINED | mcSYMFIND_MATCH_SUBSCRIPT | \
        mcSYMFIND_MATCH_VALUE)


class mcSymbolArray : public mcAbstractArray
{
protected:

 int m_nSymbolArray;

 mcSymbolArray *m_pArr[mcMAX_SYMBOL_ARRAY_NUM];

protected:

 void data_Delete(int n)
  { delete data_GetSymbol(n); }
 mcAbstractItem *data_GetCopyOf(int n) const
  { return data_GetSymbol(n)->data_Clone(); }

 void data_ResetLinkedArr() {
  for (int i=0; i < mcMAX_SYMBOL_ARRAY_NUM; i++)
   m_pArr[i] = NULL;
 }

public:

 void (*m_pAddSymbolCallback)(void);

public:

 mcSymbolArray(int type = mcSYM_NOTSET,
     void (*fnc)(void) = NULL) { 
  data_ResetLinkedArr(); 
  m_nSymbolArray = type; 
  m_pAddSymbolCallback = fnc;
 }

 virtual ~mcSymbolArray() { data_Clear(); }


 mcSymbolProperties *data_AddSymbol(bool bRemovePrevious,
         const wxString &name,
         wxFontEncoding enc = wxFONTENCODING_DEFAULT, 
         const mcRealValue &value = 0.0, 
         const wxString &inlinedsym = wxEmptyString, 
         const wxString &subscript = wxEmptyString,
         mcExtRange *domain = NULL);

 bool data_AddSymbol(const mcSymbolProperties &newsym, bool bRemovePrevious = TRUE);

 mcSymbolProperties *data_MoveSymbols(int i, mcSymbolArray *parr);

 int data_FindSymbol(long flags,
     const wxString &name, 
     wxFontEncoding enc = wxFONTENCODING_DEFAULT,
     const mcRealValue &value = 0.0, 
     const wxString &subscript = wxEmptyString, 
     const wxString &inlined = wxEmptyString,
     int occurrence = 0) const;

 int data_FindSymbol(long flags, const mcSymbolProperties &symtofind, int occ = 0) const;


 void data_LinkWithArray(mcSymbolArray *p) {
  int entry = 0;
  while (m_pArr[entry] != NULL)
   entry++;

  m_pArr[entry] = p;
 }




 mcSymbolProperties *data_GetSymbol(int n)    { return (mcSymbolProperties *)data_GetItem(n); }
 const mcSymbolProperties *data_GetSymbol(int n) const { return (const mcSymbolProperties *)data_GetItem(n); }

 wxString data_GetSymbolName(int n) const  { return data_GetSymbol(n)->m_strSymbol;}
 wxString data_GetSubscript(int n) const   { return data_GetSymbol(n)->m_strSubscript; }
 wxString io_GetInlinedSymbol(int n) const  { return data_GetSymbol(n)->io_GetInlinedSym(); }
 mcRealValue math_GetValue(int n) const   { return data_GetSymbol(n)->m_fValue; }
 wxFontEncoding data_GetEncoding(int n) const { return data_GetSymbol(n)->m_fEncoding; }
 int data_GetArrayId() const      { return m_nSymbolArray; }

};


#define mcCP_MAX_DEPTH  64

#define mcCP_UNDEFINED  -256
#define mcCP_BEGIN   -257
#define mcCP_END   -258
#define mcCP_BEGINEND  -259


class mcCursorPos : public mcGUIHelper
{
protected:

 int m_nPos[mcCP_MAX_DEPTH];
 int m_nUsed;

public:
 
 // constructor
 mcCursorPos() 
  { m_nUsed=0; }
 mcCursorPos(int pos) 
  { m_nUsed=1; m_nPos[0] = pos; }

 virtual ~mcCursorPos() {}


public:  // push, pop

 void gui_Push(int cp)
  { m_nPos[m_nUsed++] = cp; }

 void gui_Push(const mcCursorPos &c);
 void gui_Pop();

 int gui_Last() const
  { return m_nPos[0]; }

 int gui_GetLastAndPop()
  { int n=gui_Last(); gui_Pop(); return n; }


public:  // checkers

 bool isEnd() const
  { return gui_Last() == mcCP_END; }

 bool isSpecial() const
  { return isSpecial(gui_Last()); }

 bool isSpecial(int cp) const
  { return cp <= mcCP_UNDEFINED && cp >= mcCP_BEGINEND; }

 bool isBegin() const
  { return gui_Last() == mcCP_BEGIN; }

 bool isBeginEnd() const
  { return gui_Last() == mcCP_BEGINEND; }

 bool isUndefined() const
  { return gui_Last() == mcCP_UNDEFINED; }

 bool isInside() const
  { return !isBegin() && !isEnd() && !isBeginEnd() && !isUndefined(); }
};


class mcMathMngCmd : public mcGUIHelper
{
public:

 mcMathMngCmdID m_nID;
 const wxChar *m_strDescription;

public:
 mcMathMngCmd(mcMathMngCmdID id, const wxChar *desc) : m_nID(id), m_strDescription(desc) {}
 virtual ~mcMathMngCmd() {}
};


#endif    // MATHHELPERS_H

---

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

[ Top ]