Main page

---

MathCore.cpp

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     //
//                                                                   //


// optimization for GCC compiler
#ifdef __GNUG__
#pragma implementation "MathCore.h"
#endif

// includes
#include "mc/mcprec.h"
#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef mcPRECOMP
 #include "mc/MathCore.h"
 #include "mc/EmptyBox.h"
 #include "mc/Number.h"
 #include "mc/Bracket.h"
 #include "mc/Fraction.h"
 #include "mc/Function.h"
 #include "mc/Radical.h"
 #include "mc/Text.h"
 #include "mc/Symbol.h"
 #include "mc/Operator.h"
 #include "mc/AddSubOp.h" 
 #include "mc/MultDivOp.h" 
 #include "mc/Monomial.h"
 #include "mc/MathMng.h"
 #include "mc/Parenthesis.h"
 
 #include "mc/PolySolver.h"  // solvers
 #include "mc/BisectSolver.h"
 #include "mc/GenericSolver.h"
#endif


// Definition of the STATIC variables of mcMathCore
mcMathCore *mcMathCore::g_pTheInstance = NULL;
void (*mcMathCore::OnError)(const wxString &) = NULL;
mcSolverArray mcMathCore::arrSolvers;

#ifdef mcDETECT_MEMORY_LEAKS
 HFILE mcMathCore::m_hLogFile = NULL;
 FILE *mcMathCore::m_fLogAllocFile = NULL;
 char mcMathCore::m_szMsg[];
#endif




// ---------------------
// mcMATHCORE
// ---------------------

mcMathCore::mcMathCore()
{
 m_bIOEnabled = m_bGUIEnabled = m_bMathEnabled = FALSE;

 // the number of spaces used to indent debug output
 m_nIndentationStep = 4;
 m_nMaxSharing = -1;
}

mcMathCore::~mcMathCore()
{
 // shutdown subsystems: order is important !!!
 if (isGUIEnabled()) CleanupGUI();
 if (isIOEnabled()) CleanupIO();
 if (isMathEnabled()) CleanupMath();

 wxLog *logtarget = wxLog::SetActiveTarget(NULL);
 mcSAFE_DELETE(logtarget);
}

// this one is static
mcMathCore *mcMathCore::Get()
{
 mcASSERT(g_pTheInstance != NULL,
  wxT("Before using mcMathCore::Get() you must call mcMathCore::Setup()"));
 return g_pTheInstance;
}

// this one is static
void mcMathCore::Set(mcMathCore *p)
{
 if (g_pTheInstance != NULL)
  delete g_pTheInstance;
 g_pTheInstance = p;
}

void mcMathCore::Setup(bool bIO, bool bMath, bool bGUI)
{
 // create the global instance of the class
 mcMathCore::g_pTheInstance = new mcMathCore();

 // and then, init it
 // (this step cannot be done in the constructor of mcMathCore
 // because it generates calls to mcMathCore::Get() which needs
 // a working mcMathCore::g_pTheInstance pointer...)
 mcMathCore::g_pTheInstance->Init(bIO, bMath, bGUI);
}

void mcMathCore::Init(bool bIO, bool bMath, bool bGUI)
{
#ifdef mcENABLE_LOG
 wxLog::SetActiveTarget(new mcLog());
#endif

 // the order is important !!!
 if (bMath) SetupMath();
 if (bIO) SetupIO();
 if (bGUI) SetupGUI(NULL);

 mcElementHelpers::Init();
}

void mcMathCore::Cleanup()
{
 // delete the global istance of this class
 mcSAFE_DELETE(mcMathCore::g_pTheInstance);

#if 0 //def mcENABLE_LOG
 wxLog *p = wxLog::GetActiveTarget();
 wxLog::SetActiveTarget(NULL);
 mcSAFE_DELETE(p); 
#endif
}

void mcMathCore::SetupIO()
{
 m_bIOEnabled = TRUE;

 wxXml2::Init();
 //data_UpdateElemArray();
}

void mcMathCore::CleanupIO()
{
 wxXml2::Cleanup();

 m_bIOEnabled = FALSE;
 //data_UpdateElemArray();
}

void mcMathCore::SetupMath()
{
 m_bMathEnabled = TRUE;

 // first of all init mcRealValue class
 mcRealValue::Init();

 // init mcSymbol arrays
 mcSymbol::InitSymbols();

 // set the default step threshold
 mcMathCore::m_fStepThreshold = mcDEFAULT_STEP_THRESHOLD;

 // load parameters, constants, unknowns and functions
 //
 // FIXME: do we have to load any standard function/symbol, or
 //        we leave this task to the user ?
 //mcSymbol::LoadSymbols();
 //mcFunction::LoadFunctions();
 //mcSymbol::CheckSymbols();

 // init the interpreter
#ifdef mcUSE_WXSCRIPT
 wxScriptInterpreter::Init();
#endif

 // create some useful objects
 mcNumberHelpers::smath_pFour = new mcNumber(4.0);
 mcNumberHelpers::smath_pTwo = new mcNumber(2.0);
 mcNumberHelpers::smath_pOne = new mcNumber(1.0); 
 mcNumberHelpers::smath_pMinusOne = new mcNumber(-1.0);
 mcNumberHelpers::smath_pZero = new mcNumber(0.0);

 mcMonomialHelpers::smath_pZero = new mcMonomial;
 mcMonomialHelpers::smath_pZero->math_WrapNumber(0.0);
 mcMonomialHelpers::smath_pOne = new mcMonomial;
 mcMonomialHelpers::smath_pOne->math_WrapSimple(*mcNumberHelpers::smath_pOne);

 mcPolynomialHelpers::smath_pEmpty = new mcPolynomial;
 mcPolynomialHelpers::smath_pOne = new mcPolynomial;
 mcPolynomialHelpers::smath_pOne->math_WrapSimple(*mcNumberHelpers::smath_pOne);
 
 
 // check them
 mcMonomialHelpers::smath_pZero->data_Check();
 mcMonomialHelpers::smath_pOne->data_Check();
 mcPolynomialHelpers::smath_pEmpty->data_Check();
 mcPolynomialHelpers::smath_pOne->data_Check();
/* mcRange::pR = new mcRange(*mcRealValue::pNegInf, *mcRealValue::pPosInf, mcSET_N);
 mcExtRange::pR = new mcExtRange(*mcRange::pR);
*/
 mcTextHelpers::smath_pEmpty = new mcText();

 // init random generator with the number of
 // of seconds since GMT 00:00:00 Jan 1st 1970
 srand(wxGetUTCTime());

 // no functions using the mcMathCore::pElem array should be
 // called in the SetupXXX() functions 
}

void mcMathCore::CleanupMath()
{
 m_bMathEnabled = FALSE;
 
 // close the interpreter
#ifdef mcUSE_WXSCRIPT
 wxScriptInterpreter::Cleanup();
#endif

 // delete the STATIC objects
 mcSAFE_DELETE(mcNumberHelpers::smath_pOne);
 mcSAFE_DELETE(mcNumberHelpers::smath_pTwo);
 mcSAFE_DELETE(mcNumberHelpers::smath_pFour);
 mcSAFE_DELETE(mcNumberHelpers::smath_pMinusOne);
 mcSAFE_DELETE(mcNumberHelpers::smath_pZero);
 mcSAFE_DELETE(mcPolynomialHelpers::smath_pOne);
 mcSAFE_DELETE(mcPolynomialHelpers::smath_pEmpty);
 mcSAFE_DELETE(mcMonomialHelpers::smath_pOne);
 mcSAFE_DELETE(mcMonomialHelpers::smath_pZero);

 mcSAFE_DELETE(mcRange::pR);
 mcSAFE_DELETE(mcExtRange::pR);
 mcSAFE_DELETE(mcTextHelpers::smath_pEmpty);

 // clear math arrays
 arrSolvers.data_Clear();
 mcSymbol::CleanupSymbols();

 // de-init mcRealValue classes
 mcRealValue::Cleanup();
 mcElementHelpers::Cleanup();

 // delete pElem array
 //data_UpdateElemArray();
}

void mcMathCore::SetupGUI(void (*OnErrorFnc)(const wxString &))
{
 m_bGUIEnabled = TRUE;

 // be sure that also wxWidgets' GUI is correctly init...
 // if the wxXXXXX colors are okay, then the GUI should have been set up
 mcASSERT(wxWHITE != NULL, wxT("wxWidgets' GUI seems to be offline..."));

 //strMathMLOp[0] = { wxT("plus"), wxT("minus"), wxT("times"), "divide" };

 // setup STATIC variables
 mcElementHelpers::sgui_pSelectionBrush = new wxBrush(wxColour(0x40ffff), wxSOLID);
 mcElementHelpers::sgui_pActivationBrush = new wxBrush(wxColour(0xfadcb4), wxSOLID);
 mcElementArrayHelpers::sgui_pSelectionPen = new wxPen(wxColour(0, 0, 0), 1, wxDOT);
 mcEmptyBoxHelpers::sgui_pEmptyBoxBrush = new wxBrush(wxColour(0xfad2be), wxSOLID);
 mcEmptyBoxHelpers::sgui_pNewEmptyBox = new mcKey(wxT("x+127"));
 mcFractionHelpers::sgui_pNewFraction = new mcKey(wxString::Format(wxT("cx+%d"), wxT('f')));
 mcFunctionHelpers::sgui_pNewFunction = new mcKey(wxString::Format(wxT("csx+%d"), wxT('f')));
 mcRadicalHelpers::sgui_pNewRadical = new mcKey(wxString::Format(wxT("cx+%d"), wxT('r')));

 // create some standard keys required by mcElementHelpers::sgui_Input()
 // functions;
 m_pDeleteKey = new mcKey(wxString::Format(wxT("+%d"), WXK_BACK));
 m_pCancelKey = new mcKey(wxString::Format(wxT("+%d"), WXK_DELETE));
 m_pNewLineKey = new mcKey(wxString::Format(wxT("+%d"), WXK_RETURN));

 // those are special keys...
 m_pEditExpKey = new mcKey(wxString::Format(wxT("x+%d"), WXK_RETURN));
 m_pEditSubscriptKey = new mcKey(wxString::Format(wxT("cx+%d"), WXK_RETURN));

 // set the error handler function pointer
 OnError = OnErrorFnc;

 // initialize the styles of mcElementGUI
 mcElementHelpers::gui_InitDefaultStyles();
 mcMathMngHelpers::gui_InitStyles();

 //data_UpdateElemArray();
}

void mcMathCore::CleanupGUI()
{
 m_bGUIEnabled = FALSE;

 // delete mcMathCore variables
 mcSAFE_DELETE(m_pDeleteKey);
 mcSAFE_DELETE(m_pCancelKey);
 mcSAFE_DELETE(m_pNewLineKey);

 mcSAFE_DELETE(m_pEditExpKey);
 mcSAFE_DELETE(m_pEditSubscriptKey);


 // delete the STATIC pointers allocated by the various classes
 // we must be sure all customizable pointers have been deleted: they can be deleted
 // only here because when a mcFraction, mcRadical, mcEmptyBox, ..., is deleted,
 // it cannot know if the customizable resource will be required by another
 // element....
 mcSAFE_DELETE(mcElementHelpers::sgui_pSelectionBrush);
 mcSAFE_DELETE(mcElementHelpers::sgui_pActivationBrush);
 mcSAFE_DELETE(mcElementArrayHelpers::sgui_pSelectionPen);
 mcSAFE_DELETE(mcEmptyBoxHelpers::sgui_pEmptyBoxBrush);
 mcSAFE_DELETE(mcEmptyBoxHelpers::sgui_pNewEmptyBox);
 mcSAFE_DELETE(mcFractionHelpers::sgui_pNewFraction);
 mcSAFE_DELETE(mcFunctionHelpers::sgui_pNewFunction);
 mcSAFE_DELETE(mcRadicalHelpers::sgui_pNewRadical);


 // delete the style array and mark it as empty
 mcElementHelpers::gui_DeleteDefaultStyles();
 mcMathMngHelpers::gui_DeleteStyles();

 //data_UpdateElemArray();
}





// --------------------------------
// mcMATHCORE - miscellaneous
// --------------------------------

bool mcMathCore::isGUIEnabled() const
{ return m_bGUIEnabled; }

bool mcMathCore::isMathEnabled() const
{ return m_bMathEnabled; }

bool mcMathCore::isIOEnabled() const
{ return m_bIOEnabled; }

bool mcMathCore::MatchEditKeys(const mcKey &key)
{
 return m_pDeleteKey->MatchKey(key) ||
   m_pCancelKey->MatchKey(key) ||
   m_pEditSubscriptKey->MatchKey(key) ||
   m_pEditExpKey->MatchKey(key);
}

void mcMathCore::SyntaxError(wxString str)
{
 // just send a message to the 'on error' registered function
 if (OnError != NULL)
  OnError(str);
}





// --------------------------------
// mcMATHCORE - math functions
// --------------------------------

#define mcSAFE_ADD(x)     \
 { mcSolver *toadd = new x();  \
   if (!arrSolvers.math_Add(toadd)) \
    delete toadd; }


void mcMathCore::LoadDefaultSolvers()
{
 // generic solvers
 mcSAFE_ADD(mcSimplifySolver);
 mcSAFE_ADD(mcExpandSolver);

 // the polynomial solver
 mcSAFE_ADD(mcPolySolver);

 // the approximated bisection solver
 mcSAFE_ADD(mcBisectSolver);
}

---

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

[ Top ]