Main page

---

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


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

#ifndef mcPRECOMP
 #include "mc/Radical.h"
 #include "mc/Monomial.h"
#endif


mcIMPLEMENT_MAIN_CLASS(mcRadical, mcExpContainer);


// setup customizable variables
int mcRadicalHelpers::sgui_nSpaceLeftRight = 4;
int mcRadicalHelpers::sgui_nSpaceAboveBelow = 2;

wxString mcRadicalHelpers::sio_strGenericRoot = wxT("root");
wxString mcRadicalHelpers::sio_strSquareRoot = wxT("sqrt");

// This is the special key which must be used to create a new fraction
// through the mcElementGUI input system.
// This is not a simple CTRL+R combination because gui_isBeginKey() will
// return TRUE only if the given key is set as a special key.
mcKey *mcRadicalHelpers::sgui_pNewRadical = NULL;





// ----------------------------------------
// mcRADICALGUI
// ----------------------------------------

bool mcRadicalHelpers::gui_isBeginKey(const mcKey &key) const
{
 if (key.MatchKey(*sgui_pNewRadical))
  return TRUE;
 return FALSE;
}

bool mcRadicalHelpers::gui_isLeftPosEnabled() const
{
 if (data_hasProperty(mcEP_HASEXPONENT))
  return FALSE;
 return TRUE;
}

int mcRadicalHelpers::gui_GetContentOffsetY() const
{
 // take in count also the radical's sign thickness
 int h = mcElementHelpers::gui_GetThickness(NULL) + gui_GetSpaceAboveBelow();

 return h+(gui_GetHeight()-h-data_GetContent().gui_GetHeight())/2;
}

int mcRadicalHelpers::gui_GetContentOffsetX() const
{
 // take in count also exponent (or better, index) width
 return mcMAX(gui_GetExpSubSize(TRUE).GetWidth(), 5) + 
  gui_GetVWidth() + gui_GetSpaceLeftRight();
}

int mcRadicalHelpers::gui_GetExpOffsetx() const
{
 // our exponent is not a real exponent: we use it as an index
 return 0;
}

int mcRadicalHelpers::gui_GetVWidth() const
{
 return mcMAX(15, gui_GetExpSubSize(TRUE).GetWidth()/4);
}

void mcRadicalHelpers::gui_DoRecalcBaseSize()
{
 wxString tmp;
 wxScreenDC dc;

 // compute size of content
 mgui_szBase = data_GetContent().gui_GetSize();

 // update size member (due to the fact that our gui_GetExpOffsetx doesn't return
 // the with of the base, we must take in count the size of the exponent, too).
 mgui_szBase.SetWidth(mgui_szBase.GetWidth() + mcMAX(gui_GetExpSubSize(TRUE).GetWidth(), 5) +
  gui_GetSpaceLeftRight()*2 + gui_GetVWidth() + mcElementHelpers::gui_GetThickness(NULL));
 mgui_szBase.SetHeight(mgui_szBase.GetHeight() + gui_GetSpaceAboveBelow()*2 +
  mcElementHelpers::gui_GetThickness(NULL));
}

void mcRadicalHelpers::gui_DrawContainer(wxDC &hDC, int Offsetx, int Offsety, long flags, const wxPoint &pt) const
{
 // set up the pen to use to draw the symbols
 int thickness = mcElementHelpers::gui_GetThickness(NULL);
 wxPen pen(*wxBLACK, thickness, wxSOLID);
 hDC.SetPen(pen);

 //   |             ___________        | y2
 // y |    exp     /           |
 //   |   ----    /            |
 //           \  /  m_eContent
 //            \/
 //
 //      |---|-----|
 //        w    n
 //
 int y = Offsety+mcMAX(gui_GetExpSubSize(TRUE).GetHeight()+5, 15),
  y2 = Offsety+thickness/2+1,
  w = Offsetx+mcMAX(gui_GetExpSubSize(TRUE).GetWidth(), 5),
  n = gui_GetVWidth();

 // draw the exponent underlining
 hDC.DrawLine(Offsetx, y, w+1, y);  // the +1 is used to join the two lines

 // draw the V
 hDC.DrawLine(w, y, w+n/2, Offsety+gui_GetBaseSize().GetHeight());
 hDC.DrawLine(w+n/2+1, Offsety+gui_GetBaseSize().GetHeight(), w+n, y2);

 // draw the remaining lines
 hDC.DrawLine(w+n-1, y2, Offsetx+gui_GetWidth(), y2);
 hDC.DrawLine(Offsetx+gui_GetWidth(), y2, Offsetx+gui_GetWidth(), Offsety+3);
}
/*
int mcRadicalHelpers::gui_BaseMoveCursorUsingPoint(wxDC &dc, const wxPoint &p)
{
 // just check if the point is in the 
 return mcMCR_OKAY;
}
*/





// ----------------------------------------
// mcRADICALIO
// ----------------------------------------

wxXml2Node mcRadicalHelpers::io_GetBaseMathML(bool bGetPresentation) const
{
 // this is just a fake function: see mcRadicalHelpers::io_GetMathML
 return wxXml2EmptyNode;
}

wxXml2Node mcRadicalHelpers::io_GetMathML(bool bGetPresentation) const
{
 wxXml2Node p = wxXml2Node(wxXML_ELEMENT_NODE, wxXml2EmptyDoc, wxT("msqrt"));

 // do we need to show something else than the standard index "2"
 // (which, really, is not shown at all....) ?
 if (data_hasProperty(mcEP_HASEXPONENT))
  p.SetName(wxT("mroot"));

 // add to the p node, the content
 wxXml2Node content(data_GetContent().io_GetMathML(bGetPresentation));
 p.AddChild(content);

 // add the index, if necessary
 if (data_hasProperty(mcEP_HASEXPONENT)) {
  wxXml2Node exp(data_GetExp().io_GetMathML(bGetPresentation));
  p.AddChild(exp);
 }

 return p;
}

wxString mcRadicalHelpers::io_GetInlinedExpr() const
{
 wxString res = sio_strSquareRoot;
 bool needidx = FALSE;

 if (data_hasProperty(mcEP_HASEXPONENT)) {
  res = sio_strGenericRoot;
  needidx = TRUE;
 }

 res += wxT("(") + data_GetContent().io_GetInlinedExpr();

 // do we need to add the index ?
 if (needidx)
  res += wxT(", ") + data_GetExp().io_GetInlinedExpr();

 res += wxT(")");
 return res;
}

bool mcRadicalHelpers::io_ImportPresentationMathML(wxXml2Node tag, wxString &pErr)
{
 return TRUE;
}

bool mcRadicalHelpers::io_ImportBaseInlinedExpr(const wxString &str, int *count, wxString &perr)
{
 wxArrayString argarr;
 wxString arg(str);
 int totallenght;

 if (str.StartsWith(sio_strGenericRoot)) {

  // set the mcEP_HASEXPONENT property
  data_CreateExpSub(TRUE);
  totallenght = sio_strGenericRoot.Len();

 } else {

  totallenght = sio_strSquareRoot.Len();
 }

 // truncate the string to the end of the argument
 arg = arg.Right(arg.Len()-totallenght);
 wxString idx(arg);
 argarr = mcFunctionHelpers::io_ImportArgument(arg, count, perr);
 if (argarr.GetCount() == 0) return FALSE;
 totallenght += *count;

 // by now, process the first arg...
 arg = argarr[0];

 // import the 1st arg
 if (!data_GetContent().io_ImportInlinedExpr(arg, count, perr))
  return FALSE;
 mcASSERT(*count == (int)arg.Len(), wxT("The argument should have been completely imported"));

 // get the second argument (if present) 
 if (argarr.GetCount() > 1) {

  if (argarr[1].IsEmpty()) {

   // the user should have written something like: ,,
   perr = wxT("An empty argument has been found in the token: ") + str;
   return FALSE;
  }

  // import our index as the exponent...
  if (!data_GetExp().io_ImportInlinedExpr(argarr[1], count, perr))
   return FALSE;
  mcASSERT(*count == (int)argarr[1].Len(), 
   wxT("The argument should have been completely imported"));

  // this should be a generic root !

 } else {

  // check if the user called us as a generic or a square root
  if (data_hasProperty(mcEP_HASEXPONENT))
   math_GetExp().math_WrapNumber(2.0);
 }

 *count = totallenght;

 return TRUE;
}




// ----------------------------------------
// mcRADICALMATH
// ----------------------------------------

mcRealValue mcRadicalHelpers::math_Evaluate() const
{
 mcRealValue base = math_EvaluateBase();

 // if we do not have any index, then a 2.0 is the default (sqrt)
 mcRealValue idx = 2.0;

 if (math_hasIdx())
  idx = math_GetIdx().math_Evaluate();

 // now, just raise the base to the exp...
 return base.root(idx);
}

mcMathType mcRadicalHelpers::math_GetBaseMathType() const
{
 mcMathType res = mcExpContainerHelpers::math_GetBaseMathType();

 // a radical is another way to express an exp element:
 // sqrt(base, idx) = base ^ (1/idx)
 
 // since our idx is the denominator of the exponent, if we contain
 // unknowns in our idx, the global data must not be considered
 // as polynomial but as rational: unknowns are placed at den...
 if (math_hasIdx() && math_GetIdx().math_ContainsUnknowns())
  res.m_tMath1 = mcMTL1_RATIONAL;
  
 return res;
}

mcExpSimRes mcRadicalHelpers::math_SimplifyContents(long flags, mcElement *)
{
 // if the contained polynomial cannot simplify to a single
 // monomial, then we cannot do any further simplification...
 if (!data_GetContent().math_isFactorized())
  return mcESR_DONE;

 mcMonomial m = data_GetContent().math_Get(0);
 mcASSERT(m.math_GetCount() > 0, wxT("We contain only an empty monomial ?"));
 mcElement e = m.math_Get(0);

 switch (e.data_GetType()) {
 // if the contained polynomial is a perfect power of something
 // (and thus it contains only a mcBracket with exponent),
 // our work is simple... if it is not, then we can just try
 // to bring factor(s) out of the radical since the contents
 // should be completely simplified if this function has been
 // called (see mcExpContainer::math_SimplifyBase).
 case mcET_BRACKET:
  {
   mcBracket br(e);
   mcPolynomial contentexp = br.data_GetExp();  
   
   mcASSERT(!contentexp.math_EvaluatesTo(1.0),
    wxT("This mcBracket should have been already simplified..."));
   
   // now,
   //
   //   root(contents^contentexp, idx) = contents^(contentexp/idx)
   // 
   contentexp.math_SimpleDivideBy(math_GetIdx());
  }
  break;

 case mcET_NUMBER:

  // just try to bring something out...
  break;

 default:
  mcASSERT(0, wxT("TODO"));
 }

 return mcESR_DONE;
}

mcExpSimRes mcRadicalHelpers::math_ExpandContents(long flags, mcElement *)
{
 return mcESR_DONE;
}

---

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

[ Top ]