Main page

---

BisectSolver.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 "BisectSolver.h"
#endif

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

#ifndef mcPRECOMP
    #include "mc/MathUtils.h"       // for the mcLOG macro
 #include "mc/BisectSolver.h"
 #include "mc/MathSystem.h"
 #include "mc/MathAndSystem.h"
 #include "mc/MathOrSystem.h"
 #include "mc/Symbol.h"
 #include "mc/Monomial.h"
#endif





// ----------------------------------------
// mcBISECTSOLVER
// ----------------------------------------

bool mcBisectSolver::math_WorksOn(const mcMathOrSystem &m) const
{
 if (m.math_GetMathSystemType().m_tMath1 != mcMSTL1_EQUATIONS)
  return FALSE;

 // the given system must contain a single unknown
 // (which will be the unknown we are going to solve for)
 // and it must be non-parametric
 if (m.math_ContainsParameters() ||
  m.math_GetCountOfSymbolsType(&mcSymbol::arrUnknowns) > 1)
  return FALSE; 

 // mcBisectSolver accepts any type of equation systems...
 return TRUE;
}

mcRealValue mcBisectSolver::math_Bisect(mcMathLine &tosolve, const mcSymbolProperties *unk,
          const mcRealValue &a, const mcRealValue &b)
{
 // evaluate the function in the two given points
 mcRealValue fa = tosolve.math_EvaluateAt(unk, a);
 mcRealValue fb = tosolve.math_EvaluateAt(unk, b);

 return math_Bisect(tosolve, unk, a, b, fa, fb);
}

mcRealValue mcBisectSolver::math_Bisect(mcMathLine &tosolve, const mcSymbolProperties *unk,
          const mcRealValue &a, const mcRealValue &b,
          const mcRealValue &fa, const mcRealValue &fb)
{
 mcSOLVERLOG(wxT("mcBisectSolver::Bisect - bisecting in [%s,%s] where the ")
  wxT("function evaluates to [%s,%s]"), mcTXTV(a), mcTXTV(b), 
  mcTXTV(fa), mcTXTV(fb));

#ifdef __MCDEBUG__
 bool check = (a != *mcRealValue::pNAN) && (b != *mcRealValue::pNAN) &&
   (fa != *mcRealValue::pNAN) && (fb != *mcRealValue::pNAN);
 mcASSERT(check && ((fa*fb) < 0), wxT("Invalid arguments"));
#endif
 
 mcRealValue c = (a+b)/2.0;
 if (a == c || b == c)
  return c;  // we've found an exact solution !!!
  
 mcRealValue err = a-b;
 if (err.abs() < m_fDelta)
  return c;  // error is small enough for us... :-)
  
 mcRealValue fc = tosolve.math_EvaluateAt(unk, c);
 mcASSERT(fc != *mcRealValue::pNAN, wxT("Something wrong !!!"));
 
 // continue bisection in range [a;c] or [c;a]
 if (fa*fc < 0)
  return math_Bisect(tosolve, unk, a, c, fa, fc);
 return math_Bisect(tosolve, unk, c, b, fc, fb);
}

bool mcBisectSolver::math_SolveLine(mcMathLine &p, const mcSymbolProperties *unk, 
         mcSystemStepArray &steps)
{
 // no unknowns set by mcSolver::math_PreSolve ?
 mcASSERT(unk != NULL, wxT("We need the main unknown !!"));
 mcSOLVERLOG(wxT("mcBisectSolver::math_SolveLine - The unknown is [%s]."), mcTXTP(unk));

 // okay; we can start with the real resolution of the given data,
 // storing all the steps in the given array...
 
 // STEP #1: find the first a,b
 mcRealValue a = m_rStart.data_GetRange(0)->math_GetLowerLimitValue(), 
   b = m_rStart.data_GetRange(0)->math_GetUpperLimitValue();
 mcSOLVERLOG(wxT("mcBisectSolver::math_SolveLine - the start range is [%s,%s]."), 
    mcTXTV(a), mcTXTV(b));

 // STEP #2: begin bisection there
 mcRealValue res = math_Bisect(p, unk, a, b);
 mcSOLVERLOG(wxT("mcBisectSolver::math_SolveLine - Approximated solution is %s"), 
            mcTXTV(res));

 // STEP #3: store the solution found in a new step...
 p.math_SetMathType(mcMMT_EQUATION);
 p.data_GetLeftMem().math_WrapSymbol(unk);
 p.data_GetRightMem().math_WrapNumber(res);
 steps.data_AddLine(p);

 // we managed to find a (approximated) solution...
 return TRUE;
}

bool mcBisectSolver::math_isReady() const
{
 if (m_rStart.math_isFinite())
  return TRUE;
 return FALSE;
}

bool mcBisectSolver::math_SetStartRange(const mcRange &r, const mcMathLine &p,
          const mcSymbolProperties *sym)
{
 const mcSymbolProperties *unk=sym;

 // if the given mcSymbolProperties pointer is NULL,
 // then we have to find the unknown ourselves...
 if (!unk) {

  for (int i=0; i<mcSymbol::arrUnknowns.data_GetCount(); i++) {
   mcSymbolProperties *curr = mcSymbol::arrUnknowns.data_GetSymbol(i);
   if (p.math_ContainsSymbol(curr))
    unk = curr;
  }

  if (!unk)
   return FALSE;
 }

 // TODO: check that the function is continue

 // check that at the extremes of the given range, the function
 // assumes values with different signs...
 mcRealValue a = r.math_GetLowerLimitValue(), 
   b = r.math_GetUpperLimitValue();
 mcRealValue fa = p.math_EvaluateAt(unk, a);
 mcRealValue fb = p.math_EvaluateAt(unk, b);

 if (fa*fb > 0)
  return FALSE;  // if does not change sign in the given range

 // it is okay
 m_rStart.data_DeepCopy(r);
 return TRUE;
}

---

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

[ Top ]