Main page

---

Solver.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 SOLVER_H
#define SOLVER_H

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

// required includes
#include <wx/panel.h>
#include "mc/Range.h"
#include "mc/MathLine.h"


// these will be defined later...
class mcMathOrSystem;
class mcLineStepArray;
class mcSystemStepArray;


#define mcSOLVER_MAXLINES    16

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


class mcSolver 
{
protected:  // member variables

 mcSolverType m_nType;

 wxString m_strName;

 wxString m_strDesc; 

 wxString m_strLastErr;

 mcRealValue m_fLastLenght;


protected:  // handy variables

 const mcSymbolProperties *m_pUnkArr[mcSOLVER_MAXLINES];

 void math_ResetUnkArray();


protected:  // utilities

 //mcMathMng *math_GetNewStep(const mcMathMng *last);

 //mcMathMng *math_GetNewSmartStep(const mcMathMng *last);

 mcSymbolProperties *math_GetUnknown(const mcMathOrSystem &sys, int n) const;


protected:  // simplify/expand

 void math_DoSimplifyStep(long lflags, long rflags, mcMathLine &tosimplify, 
       mcSystemStepArray &steps, mcExpSimRes *p = NULL);

 void math_DoCompleteSimplification(long lflags, long rflags, mcMathLine &tosimplify, 
       mcSystemStepArray &steps);

 void math_DoExpandStep(long lflags, long rflags, mcMathLine &tosimplify, 
       mcSystemStepArray &steps, mcExpSimRes *p = NULL);
 
 void math_DoCompleteExpansion(long lflags, long rflags, mcMathLine &tosimplify, 
       mcSystemStepArray &steps);

 void math_SplitInTwoEquations(const mcPolynomial &lfirsteq, const mcPolynomial &lseceq,
    const mcPolynomial &rfirsteq, const mcPolynomial &rseceq, mcSystemStepArray &steps,
    mcLogicOperator conn = mcLO_OR);
 void math_SplitInTwoEquations(mcMathLine *firsteq, mcMathLine *seceq,
    mcSystemStepArray &steps, mcLogicOperator conn = mcLO_OR);
 void math_SplitInTwoEquations(const mcMathLine &firsteq, const mcMathLine &seceq,
    mcSystemStepArray &steps, mcLogicOperator conn = mcLO_OR);


public:
 mcSolver() { math_ResetUnkArray(); }
 virtual ~mcSolver() {}




 wxString math_GetDesc() const   { return m_strDesc; }

 wxString math_GetName() const   { return m_strName; }

 wxString math_GetLastErr() const  { return m_strLastErr; }

 mcSolverType math_GetType() const  { return m_nType; }





 virtual void data_Check() const;

 virtual bool math_PreSolve(const mcMathOrSystem &, mcSystemStepArray &);
 virtual bool math_PostSolve(const mcMathOrSystem &, mcSystemStepArray &);





 virtual bool math_WorksOn(const mcMathOrSystem &) const = 0;

 virtual bool math_WorksOn(const mcMathOrSystem &, 
  const mcSymbolProperties *unk) const { return TRUE; }

 virtual bool math_Solve(const mcMathOrSystem &, mcSystemStepArray &);

 virtual bool math_SolveLine(mcMathLine &, const mcSymbolProperties *unk, 
        mcSystemStepArray &) = 0;

 virtual bool math_isReady() const = 0;

 virtual wxPanel *gui_GetOptionsPanel() const = 0;

};




class mcSolverArray : public mcAbstractArray
{
protected: 
 void data_Delete(int n)
  { delete data_Get(n); }

public:
 mcSolverArray() {}
 virtual ~mcSolverArray() { data_Clear(); }


 bool math_Add(mcSolver *solver);

 bool math_Contains(const mcSolver *) const;

 wxArrayString io_GetDescArray() const;

 void data_Check() const;

 mcSolver *data_Get(int i)    { return (mcSolver *)data_GetItem(i); }
 const mcSolver *data_Get(int i) const { return (mcSolver *)data_GetItem(i); }
};



/*
class mcLineStepArray : public mcAbstractArray
{
protected:
 void data_Delete(int n)  { delete data_Get(n); }

public:
 mcLineStepArray() {}
 virtual ~mcLineStepArray() { data_Clear(); }

 int data_RemoveSimpleSteps();

 const mcMathMng *data_Get(int n) const { return (const mcMathMng *)data_GetItem(n); }
 mcMathMng *data_Get(int n)    { return (mcMathMng *)data_GetItem(n); }

 void data_Check() const;
};*/


#define mcSYSTEMSTEPARR_NOFLAGS    0

#define mcSYSTEMSTEPARR_DISCARD_SIMPLE  1


class mcSystemStepArray : public mcAbstractArray
{
#ifdef mcENABLE_DATA
protected:

 long m_nFlags;

#endif



public:
 mcSystemStepArray(long flags = mcSYSTEMSTEPARR_NOFLAGS) { m_nFlags=flags; }
 virtual ~mcSystemStepArray() { data_Clear(); }


#ifdef mcENABLE_DATA
protected:

 void data_Delete(int n);

public:

 int math_RemoveIdenticSteps();

 int math_RemoveSimpleSteps();

 void data_AddSys(mcMathOrSystem *pointer);

 void data_AddFinalSys(mcMathOrSystem *pointer);

 void data_AddSysOnlyIfComplexEnough(mcMathOrSystem *pointer);

 void data_AddLine(const mcMathLine &p);

 void data_AddKeyLine(const mcMathLine &p);

 void data_AddLineOnlyIfComplexEnough(const mcMathLine &p);

 //void data_AddLines(mcLineStepArray &steps, int j);

 void data_MergeSystems(mcSystemStepArray &, int i);

 void data_Check() const;

 const mcMathOrSystem *data_Get(int n) const 
  { return (const mcMathOrSystem *)data_GetItem(n); }
 mcMathOrSystem *data_Get(int n)
  { return (mcMathOrSystem *)data_GetItem(n); }
 const mcMathOrSystem *data_GetLast() const 
  { return data_Get(data_GetCount()-1); }
 mcMathOrSystem *data_GetLast()
  { return data_Get(data_GetCount()-1); }

#endif  // mcENABLE_DATA


#ifdef mcENABLE_MATH
public:

 void math_AppendCombinationOf(const mcSystemStepArray &arr1,
        const mcSystemStepArray &arr2,
        mcLogicOperator lo);
#endif  // mcENABLE_MATH


#ifdef mcENABLE_IO
public:
 
 wxString io_GetInlinedExpr() const;

#endif  // mcENABLE_IO
};

#endif  // SOLVER_H

---

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

[ Top ]