Main page

---

MathUtils.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 MATHUTILS_H
#define MATHUTILS_H

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


// -----------
// INCLUDES
// -----------

#include "mc/Setup.h"  // contains all mcENABLE_XXX defines
#include <wx/bitmap.h>
#include <wx/log.h>   // for the mcLOG macro
#include "wx/xml2.h"

// these will be defined later... we just need them for mcStyle::gui_Select function
class mcElement;
class mcRealValue;




// -----------
// DEFINES
// -----------

#if defined(mcENABLE_LOG)

 // MathCore uses the wxWidgets' logging system:
 // it allows to exclude selectively some type of logs.
 // our logs are divided in some main types:
 enum {
  mcLOG_Generic = 1024,  // MathCore log level start here
  mcLOG_Math,
  mcLOG_GUI,
  mcLOG_IO
 };


 class mcLog : public wxLog
 {
  FILE *m_fp;

 public:
  mcLog(FILE *p = NULL) { m_fp = p; if (!m_fp) m_fp = stderr; }
  virtual ~mcLog() {}

  void DoLogString(const wxChar *msg, time_t timestamp);
 };

#endif

#if defined(mcENABLE_LOG) && \
 !(defined(__GNUG__) && defined(__WXMSW__)) // actually there is an inexplicable bug when using MinGW and mcENABLE_LOG is defined...


 #define mcDECLARE_MATHCORE_LOG_FUNCTION(level)        \
  extern void WXDLLEXPORT mcVLog##level(const wxChar *szFormat,     \
            va_list argptr);      \
  extern void WXDLLEXPORT mcLog##level(const wxChar *szFormat,      \
           ...) ATTRIBUTE_PRINTF_1


 mcDECLARE_MATHCORE_LOG_FUNCTION(Generic);
 mcDECLARE_MATHCORE_LOG_FUNCTION(Math);
 mcDECLARE_MATHCORE_LOG_FUNCTION(GUI);
 mcDECLARE_MATHCORE_LOG_FUNCTION(IO);


 #define mcLOG       mcLogGeneric

 #define mcGUILOG      mcLogGUI

 #define mcMATHLOG      mcLogMath

 #define mcIOLOG       mcLogIO

 #define mcSOLVERLOG      mcLogMath

#else

 #ifdef __GNUG__
 
  // GCC accepts variadic macros and this avoids us a *lot* of
  // warnings about "statements with no effects" that it ouputs
  // if mcLOG is defined to nothing...
  #define mcLOG(...)        {;}
  #define mcMATHLOG(...)       {;}
  #define mcGUILOG(...)       {;}
  #define mcIOLOG(...)       {;}
  #define mcSOLVERLOG(...)      {;}
 #else

  // If all compilers supported the variadic macros (macros with a variable
  // number of arguments, declared using ... and __VA_ARGS__), then it would
  // be simpler to write these macros !!
  #define mcLOG        /* expand to nothing */
  #define mcMATHLOG       /* expand to nothing */
  #define mcGUILOG       /* expand to nothing */
  #define mcIOLOG        /* expand to nothing */
  #define mcSOLVERLOG       /* expand to nothing */
 #endif

#endif

#define mcTXT(x)    ((x).io_GetInlinedExpr().c_str())

#define mcTXTP(x)    ((x)->io_GetInlinedExpr().c_str()) 

#define mcTXTV(x)    ((x).GetSmartStr().c_str())

#define mcTXTTHIS    (this->io_GetInlinedExpr().c_str()) 

// define some useful UNICODE & ANSI support functions: if you want to
// avoid #ifdefs in your source code, do not use strlen() or wcslen();
// use wxStrlen(), wxStrcpy() or wxStrcat()
#ifndef wxStrcpy
 #ifdef __UNICODE__
  #define wxStrcpy  wcscpy
 #else
  #define wxStrcpy  strcpy
 #endif
#endif

#ifndef wxStrcpy
 #ifdef __UNICODE__
  #define wxStrcat  wcscat
 #else
  #define wxStrcat  strcat
 #endif
#endif



// define the mcEXPORT & mcIMPORT macros which must be put everywhere
// something must be exported in the DLL, when we are building a DLL
// instead of a simple LIB
#if defined(__MCMSW__)
    /*
       __declspec works in BC++ 5 and later, Watcom C++ 11.0 and later as well
       as VC++ and gcc
     */
#    if defined(__VISUALC__) || defined(__BORLANDC__) || defined(__GNUC__) || defined(__WATCOMC__)
#        define mcEXPORT __declspec(dllexport)
#        define mcIMPORT __declspec(dllimport)
#    else /* compiler doesn't support __declspec() */
#        define mcEXPORT
#        define mcIMPORT
#    endif
#elif defined(__MCPM__)
#    if defined (__WATCOMC__)
#        define mcEXPORT __declspec(dllexport)
        /*
           __declspec(dllimport) prepends __imp to imported symbols. We do NOT
           want that!
         */
#        define mcIMPORT
#    elif (!(defined(__VISAGECPP__) && (__IBMCPP__ < 400 || __IBMC__ < 400 )))
#        define mcEXPORT _Export
#        define mcIMPORT _Export
#    endif
#elif defined(__MCMAC__) || defined(__MCCOCOA__)
#    ifdef __MWERKS__
#        define mcEXPORT __declspec(export)
#        define mcIMPORT __declspec(import)
#    endif
#endif

/* for other platforms/compilers we don't anything */
#ifndef mcEXPORT
#    define mcEXPORT
#    define mcIMPORT
#endif





// ------------------------
// MISCELLANEOUS MACROS
// ------------------------

// function-like macros used to create new empty elements...
#define mcNewAddOp()   mcElementHelpers::data_NewElem(mcET_ADDOP)
#define mcNewSubOp()   mcElementHelpers::data_NewElem(mcET_SUBOP)
#define mcNewMultOp()   mcElementHelpers::data_NewElem(mcET_MULTOP)
#define mcNewDivOp()   mcElementHelpers::data_NewElem(mcET_DIVOP)
#define mcNewSymbol()   mcElementHelpers::data_NewElem(mcET_SYMBOL)
#define mcNewEmptyBox()   mcElementHelpers::data_NewElem(mcET_EMPTYBOX)
#define mcNewNumber()   mcElementHelpers::data_NewElem(mcET_NUMBER)
#define mcNewFunction()   mcElementHelpers::data_NewElem(mcET_FUNCTION)
#define mcNewFraction()   mcElementHelpers::data_NewElem(mcET_FRACTION)
#define mcNewBracket()   mcElementHelpers::data_NewElem(mcET_BRACKET)
#define mcNewMonomial()   mcElementHelpers::data_NewElem(mcET_MONOMIAL)
#define mcNewPolynomial()  mcElementHelpers::data_NewElem(mcET_POLYNOMIAL)


// just to give a standard naming to macros...

#define wxDEFINE_CLASS(x)   /*DECLARE_CLASS(x)*/

#define wxIMPLEMENT_CLASS(x, y)  /*IMPLEMENT_CLASS(x, y)*/





// ----------------------------------------------------
// MACROS FOR FUNCTION DEFINITION & IMPLEMENTATION 
// ----------------------------------------------------

#define mcDEFINE_CUSTOM_CLONE_FNC(x)        \
 mc##x x##Clone() const;

#define mcDEFINE_HELPER_GETMEMORYINFO_FNC(x)      \
 int data_GetMemoryInfo() const         \
  { return sizeof(x##Helpers); }

#define mcDEFINE_DEBUGNAME_FNC(x)         \
 wxString data_GetDebugName() const        \
  { return wxT(#x); }

#ifdef mcENABLE_COW_DEEPDEBUG
 #define mcDEFINE_HELPER_CLONE_FNC(x)        \
  virtual mcElementHelpers *data_Clone() const {     \
   mcLOG(#x wxT("Helpers::Clone"));       \
   x##Helpers *clone = new x##Helpers();      \
   clone->data_DeepCopy(this);         \
   return clone;            \
  }
#else
 #define mcDEFINE_HELPER_CLONE_FNC(x)        \
  virtual mcElementHelpers *data_Clone() const {     \
   x##Helpers *clone = new x##Helpers();      \
   clone->data_DeepCopy(this);         \
   return clone;            \
  }
#endif

#define mcDEFINE_HELPER_GETTYPE_FNC(x)        \
 mcElementType data_GetType() const  { return x; }

#define mcDEFINE_ASSIGNMENT_OPERATOR(x)         \
 x &operator=(const x &e)           \
  { if (this != &e) { data_UnRef(); data_Ref(e); } return *this; }

#define mcDEFINE_COMPARISON_OPERATORS(x)             \
    bool operator==(const x &e) const               \
        { const mcElementHelpers *data = (const mcElementHelpers *)e.data_GetRefData();  \
        return data_GetRefData() ? (data && chlp()->data_isSameAs(data)) : !data; }  \
    bool operator!=(const x &e) const  { return !(*this == e); }

#define mcDEFINE_ABSTRACT_CONSTRUCTORS(x, baseclass)      \
 x(const mcElementHelpers *p) : baseclass(p) { data_CheckContainer(); } \
 x(const mcElement &v) : baseclass(v.hlp()) { data_CheckContainer(); } \
 x(const x &toref) { data_Ref(toref); }         \
 x() { /* cannot create our helpers since we're abstract... */ }   \
 virtual ~x() {}

#define mcDEFINE_MAIN_CONSTRUCTORS(x, baseclass)       \
 x(const mcElementHelpers *p) : baseclass(p) { data_CheckContainer(); } \
 x(const mcElement &v) : baseclass(v.hlp()) { data_CheckContainer(); } \
 x(const x &toref) { data_Ref(toref); }         \
 x() { data_SetRefData(new x##Helpers); }        \
 virtual ~x() {}

#define mcDEFINE_REFERENCE_DATA(x, type)        \
 public:                \
  mcDEFINE_HELPER_GETMEMORYINFO_FNC(x)       \
  mcDEFINE_HELPER_CLONE_FNC(x)         \
  mcDEFINE_HELPER_GETTYPE_FNC(type)        \
  mcDEFINE_DEBUGNAME_FNC(x)








#ifdef __MCDEBUG__
 #define mcGETTER   /* expand to nothing */
 #define mcWRAPPER   /* expand to nothing */
#else
    // FIXME: by now, leave everything as if in debug mode: defining MCGETTER to
    // inline makes the release build fail due to a lot of unresolved externals...
    //#define mcGETTER   /* expand to nothing */
 #define mcGETTER   inline  // should be a very important optimization
 #define mcWRAPPER   inline  // should be a very important optimization
#endif

#define mcDEFINE_HLP_GETTER(x)           \
  \
 mcGETTER x##Helpers *hlp()   { return (x##Helpers *)mcElement::phlp(); }           \
 \
  mcGETTER const x##Helpers *hlp() const { return (const x##Helpers *)mcElement::chlp(); }

#define mcDEFINE_HLP_CP_GETTER(x)          \
 mcGETTER x##Helpers *phlp()  { return (x##Helpers *)mcElement::phlp(); }  \
  mcGETTER const x##Helpers *chlp() const  { return (const x##Helpers *)mcElement::chlp(); }

#define mcDEFINE_CLASS(x)      \
 mcDEFINE_HLP_GETTER(mc##x)     \
 mcDEFINE_HLP_CP_GETTER(mc##x)    \
 mcDEFINE_ASSIGNMENT_OPERATOR(mc##x)   \
 mcDEFINE_COMPARISON_OPERATORS(mc##x)  \
 mcDEFINE_DEBUGNAME_FNC(mc##x)

#define mcDEFINE_HELPER_CLASSES(x)  \
 class x;       \
 class x##Helpers;

#define mcDEFINE_ABSTRACT_CLASS(x, baseclass)   \
public:             \
 mcDEFINE_CLASS(x)         \
 mcDEFINE_ABSTRACT_CONSTRUCTORS(mc##x, baseclass)

#define mcDEFINE_MAIN_CLASS(x, baseclass)   \
public:            \
 mcDEFINE_CLASS(x)        \
 mcDEFINE_MAIN_CONSTRUCTORS(mc##x, baseclass)






#define mcIMPLEMENT_HLP_GETTER(x)                 \
 mcGETTER x##Helpers *x::hlp()    { return (x##Helpers *)mcElement::phlp(); }   \
 mcGETTER const x##Helpers *x::hlp() const { return (const x##Helpers *)mcElement::chlp(); } \

#define mcIMPLEMENT_HLP_CP_GETTER(x)                \
 mcGETTER x##Helpers *x::phlp()    { return (x##Helpers *)mcElement::phlp(); }   \
 mcGETTER const x##Helpers *x::chlp() const { return (const x##Helpers *)mcElement::chlp(); }

#define mcIMPLEMENT_MAIN_CLASS(x, baseclass)  \
 /*mcIMPLEMENT_HLP_GETTER(x)      \
 mcIMPLEMENT_HLP_CP_GETTER(x)*/

#define mcIMPLEMENT_ABSTRACT_CLASS(x, baseclass) \
 /*mcIMPLEMENT_HLP_GETTER(x)      \
 mcIMPLEMENT_HLP_CP_GETTER(x)*/


#define mcCREATE_HELPER_CLASSES(x)  data_SetRefData(new x##Helpers());







#define mcSAFE_DELETE(x)     { if (x) delete x; x = NULL; }

#define mcSAFE_DELETE_ARRAY(x)    { if (x) delete [] x; x = NULL; }

#define mcRETURN_ELEMENT_CHILD(n, baseclass)  \
 if (n < baseclass::data_GetChildrenCount())  \
  return baseclass::data_GetConstChild(n); \
 n -= baseclass::data_GetChildrenCount();

#define mcSET_ELEMENT_CHILD(n, baseclass, p)  \
 if (n < baseclass::data_GetChildrenCount()) { \
  baseclass::data_SetChild(n, p);    \
  return;          \
 }             \
  n -= baseclass::data_GetChildrenCount();


#define mcSIGN(x)    (((x) < 0) ? -1 : 1)

#define mcMAX(x, y)    (((x) < (y)) ? (y) : (x))

#define mcMIN(x, y)    (((x) < (y)) ? (x) : (y))

#define mcSWAP(type, x, y)  { type tmp = x; x = y; y = tmp; }

#define mcDBL_MAX    1.7976931348623157e+308

#define mcINT_MAX    2147483647

#define mcGETRED(c)    (((wxInt32)(c)) & 255)

#define mcGETGREEN(c)   ((((wxInt32)(c)) >> 8) & 255)

#define mcGETBLUE(c)   ((((wxInt32)(c)) >> 16) & 255)

#define mcINITWX(x)    (wxColour(mcGETRED(x), mcGETGREEN(x), mcGETBLUE(x)))

#define mcRGB_ENCODE(r, g, b)  (wxUint32) ((wxUint8)(r) |  \
    ((wxUint16)(g) << 8)) | (((wxUint32)((b) << 16))

#if wxCHECK_VERSION(2, 5, 1)
 #define mcUNUSED(x)   wxUnusedVar(x)
#else
 #define mcUNUSED(x)   { x == x; }
#endif

#define mcEXTEND_ARRAY(type, parray, oldsize, newsize)   \
 {               \
  type *pnew = new type[newsize];       \
  for (int e=0; e < oldsize; e++)       \
   pnew[e] = parray[e];         \
  delete [] parray;          \
  parray = pnew;           \
 }


#define mcASSERT(x, desc)   wxASSERT_MSG(x, wxT("\n\n") desc wxT("\n\n"));






// ------------------
// GLOBAL FUNCTIONS
// ------------------

int wxFindOneOf(const wxString &str, const wxString &tofind);

wxString wxIndent(const wxString &str, int indent);

wxBitmap *wxLoadMaskForXPM(char **xpm, const wxColour &mask);



#endif // MATHUTILS_H

---

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

[ Top ]