CNormalGeneralPower Class Reference

#include <CNormalGeneralPower.h>

Inheritance diagram for CNormalGeneralPower:

Collaboration diagram for CNormalGeneralPower:

Public Types
enum	Type { POWER = 0, MODULO, INVALID }

Public Member Functions
bool	checkIsOne () const
	CNormalGeneralPower ()
	CNormalGeneralPower (const CNormalGeneralPower &src)
virtual CNormalBase *	copy () const
CNormalFraction &	getLeft ()
const CNormalFraction &	getLeft () const
CNormalFraction &	getRight ()
const CNormalFraction &	getRight () const
Type	getType () const
void	multiply (const CNormalGeneralPower &generalPower)
bool	operator< (const CNormalGeneralPower &rhs) const
CNormalGeneralPower &	operator= (const CNormalGeneralPower &src)
bool	operator== (const CNormalGeneralPower &rhs) const
void	setLeft (const CNormalFraction &left)
void	setRight (const CNormalFraction &right)
void	setType (Type type)
virtual bool	simplify ()
virtual std::string	toString () const
virtual	~CNormalGeneralPower ()
Public Member Functions inherited from CNormalBase
virtual bool	areEqual (const CNormalBase &rhs) const
virtual	~CNormalBase ()

Static Public Member Functions
static CNormalGeneralPower *	createUnitGeneralPower ()

Protected Attributes
CNormalFraction *	mpLeft
CNormalFraction *	mpRight
Type	mType

Static Protected Attributes
static const char *	SYMBOLS [] = {"^", "%"}

Detailed Description

Definition at line 28 of file CNormalGeneralPower.h.

Member Enumeration Documentation

enum CNormalGeneralPower::Type

Enumerator
POWER
MODULO
INVALID

Definition at line 31 of file CNormalGeneralPower.h.

    {
      POWER = 0,
      MODULO,
      INVALID
    };

Constructor & Destructor Documentation

CNormalGeneralPower::CNormalGeneralPower

(

)

Definition at line 34 of file CNormalGeneralPower.cpp.

Referenced by copy(), createUnitGeneralPower(), and multiply().

                                        : CNormalBase(), mType(CNormalGeneralPower::INVALID), mpLeft(NULL), mpRight(NULL)
{}

CNormalGeneralPower::CNormalGeneralPower

(

const CNormalGeneralPower &

src

)

Definition at line 37 of file CNormalGeneralPower.cpp.

                                                                      : CNormalBase(src), mType(src.getType()), mpLeft(new CNormalFraction(src.getLeft())), mpRight(new CNormalFraction(src.getRight()))
{}

CNormalGeneralPower::~CNormalGeneralPower ( )

virtual

Definition at line 40 of file CNormalGeneralPower.cpp.

References mpLeft, and mpRight.

{
  if (this->mpLeft != NULL) delete this->mpLeft;
  if (this->mpRight != NULL) delete this->mpRight;
}

Member Function Documentation

bool CNormalGeneralPower::checkIsOne

(

)

const

Definition at line 265 of file CNormalGeneralPower.cpp.

References CNormalFraction::checkIsOne(), CNormalFraction::checkIsZero(), mpLeft, and mpRight.

Referenced by CNormalSum::checkIsOne(), multiply(), CNormalSum::simplify(), and CNormalProduct::simplify().

  {
    // the general power is one if either the exponent is 0.0
    // or if the base is 1.0
    return (this->mpLeft->checkIsOne() ||
            this->mpRight->checkIsZero());
  }

CNormalBase * CNormalGeneralPower::copy ( ) const

virtual

Implements CNormalBase.

Definition at line 176 of file CNormalGeneralPower.cpp.

References CNormalGeneralPower().

  {
    return new CNormalGeneralPower(*this);
  }

CNormalGeneralPower * CNormalGeneralPower::createUnitGeneralPower ( )

static

Returns a general power that is (1/1)^(1/1). It creates a new general power of type power and sets the left and right side to a unit fraction.

Definition at line 273 of file CNormalGeneralPower.cpp.

References CNormalGeneralPower(), CNormalFraction::createUnitFraction(), mpLeft, mpRight, POWER, and setType().

{
  CNormalGeneralPower* pGeneralPower = new CNormalGeneralPower();
  pGeneralPower->setType(CNormalGeneralPower::POWER);
  delete pGeneralPower->mpLeft;
  delete pGeneralPower->mpRight;
  pGeneralPower->mpLeft = CNormalFraction::createUnitFraction();
  pGeneralPower->mpRight = CNormalFraction::createUnitFraction();
  return pGeneralPower;
}

CNormalFraction & CNormalGeneralPower::getLeft

(

)

Definition at line 92 of file CNormalGeneralPower.cpp.

References mpLeft.

Referenced by convertToCEvaluationNode(), CNormalProduct::getDenominator(), normalize_variable_names(), operator=(), CNormalProduct::setDenominatorsOne(), and CNormalSum::simplify().

{
  return *this->mpLeft;
}

const CNormalFraction & CNormalGeneralPower::getLeft

(

)

const

Definition at line 97 of file CNormalGeneralPower.cpp.

References mpLeft.

  {
    return *this->mpLeft;
  }

CNormalFraction & CNormalGeneralPower::getRight

(

)

Definition at line 108 of file CNormalGeneralPower.cpp.

References mpRight.

Referenced by convertToCEvaluationNode(), normalize_variable_names(), operator=(), and CNormalSum::simplify().

{
  return *this->mpRight;
}

const CNormalFraction & CNormalGeneralPower::getRight

(

)

const

Definition at line 113 of file CNormalGeneralPower.cpp.

References mpRight.

  {
    return *this->mpRight;
  }

CNormalGeneralPower::Type CNormalGeneralPower::getType

(

)

const

Definition at line 124 of file CNormalGeneralPower.cpp.

References mType.

Referenced by convertToCEvaluationNode(), CNormalProduct::getDenominator(), operator=(), and CNormalProduct::setDenominatorsOne().

  {
    return this->mType;
  }

void CNormalGeneralPower::multiply

(

const CNormalGeneralPower &

generalPower

)

Definition at line 181 of file CNormalGeneralPower.cpp.

References checkIsOne(), CNormalSum::checkIsOne(), CNormalGeneralPower(), CNormalFraction::createUnitFraction(), CNormalFraction::getDenominator(), CNormalFraction::getNumerator(), CNormalSum::getProducts(), mpLeft, mpRight, CNormalProduct::multiply(), POWER, setLeft(), CNormalFraction::setNumerator(), setRight(), and setType().

Referenced by CNormalProduct::getDenominator(), and CNormalProduct::simplify().

{
  // make sure we don't multiply with a general power that is 1
  // this would make the simplification process more complicated.
  if (generalPower.checkIsOne()) return;
  if (this->checkIsOne())
    {
      delete this->mpLeft;
      delete this->mpRight;
      this->mpLeft = new CNormalFraction(*generalPower.mpLeft);
      this->mpRight = new CNormalFraction(*generalPower.mpRight);
    }
  else
    {
      // (A/B)^(C/D)*(E/F)^(G/H) -> // (A^(C/D)*E^(G/H))/(B^(C/D)*F^(G/H))
      // new exponent is 1
      CNormalFraction* pNewExponent = CNormalFraction::createUnitFraction();
      // initialize the new base with 1
      CNormalFraction* pNewBase = CNormalFraction::createUnitFraction();
      // the numerator of the new base is (A^(C/D)*E^(G/H))
      CNormalProduct* pTmpProduct = (*pNewBase->getNumerator().getProducts().begin());
      assert(pTmpProduct != NULL);
      // A^(C/D)
      if (!this->mpLeft->getNumerator().checkIsOne())
        {
          CNormalGeneralPower* pTmpPower = new CNormalGeneralPower();
          pTmpPower->setType(CNormalGeneralPower::POWER);
          CNormalFraction* pTmpFraction = new CNormalFraction(*pNewExponent);
          pTmpFraction->setNumerator(this->mpLeft->getNumerator());
          pTmpPower->setLeft(*pTmpFraction);
          delete pTmpFraction;
          pTmpPower->setRight(*this->mpRight);
          pTmpProduct->multiply(*pTmpPower);
          delete pTmpPower;
        }
      // E^(G/H)
      if (!generalPower.mpLeft->getNumerator().checkIsOne())
        {
          CNormalGeneralPower* pTmpPower = new CNormalGeneralPower();
          pTmpPower->setType(CNormalGeneralPower::POWER);
          CNormalFraction* pTmpFraction = new CNormalFraction(*pNewExponent);
          pTmpFraction->setNumerator(generalPower.mpLeft->getNumerator());
          pTmpPower->setLeft(*pTmpFraction);
          delete pTmpFraction;
          pTmpPower->setRight(*generalPower.mpRight);
          pTmpProduct->multiply(*pTmpPower);
          delete pTmpPower;
        }
      // the denominator of the new base is (B^(C/D)*F^(G/H))
      pTmpProduct = (*pNewBase->getDenominator().getProducts().begin());
      assert(pTmpProduct != NULL);
      // B^(C/D)
      if (!this->mpLeft->getDenominator().checkIsOne())
        {
          CNormalGeneralPower* pTmpPower = new CNormalGeneralPower();
          pTmpPower->setType(CNormalGeneralPower::POWER);
          CNormalFraction* pTmpFraction = new CNormalFraction(*pNewExponent);
          pTmpFraction->setNumerator(this->mpLeft->getDenominator());
          pTmpPower->setLeft(*pTmpFraction);
          delete pTmpFraction;
          pTmpPower->setRight(*this->mpRight);
          pTmpProduct->multiply(*pTmpPower);
          delete pTmpPower;
        }
      // F^(G/H)
      if (!generalPower.mpLeft->getDenominator().checkIsOne())
        {
          CNormalGeneralPower* pTmpPower = new CNormalGeneralPower();
          pTmpPower->setType(CNormalGeneralPower::POWER);
          CNormalFraction* pTmpFraction = new CNormalFraction(*pNewExponent);
          pTmpFraction->setNumerator(generalPower.mpLeft->getDenominator());
          pTmpPower->setLeft(*pTmpFraction);
          delete pTmpFraction;
          pTmpPower->setRight(*generalPower.mpRight);
          pTmpProduct->multiply(*pTmpPower);
          delete pTmpPower;
        }
      delete this->mpRight;
      this->mpRight = pNewExponent;
      delete this->mpLeft;
      this->mpLeft = pNewBase;
    }
}

bool CNormalGeneralPower::operator<

(

const CNormalGeneralPower &

rhs

)

const

Definition at line 145 of file CNormalGeneralPower.cpp.

References mpLeft, mpRight, and mType.

  {
    bool result = false;
    if (this->mType < rhs.mType)
      {
        result = true;
      }
    else if (this->mType == rhs.mType)
      {
        if ((*this->mpLeft) < (*rhs.mpLeft))
          {
            result = true;
          }
        else if ((*this->mpLeft) == (*rhs.mpLeft))
          {
            result = ((*this->mpRight) < (*rhs.mpRight));
          }
      }
    return result;
  }

CNormalGeneralPower & CNormalGeneralPower::operator=

(

const CNormalGeneralPower &

src

)

Definition at line 46 of file CNormalGeneralPower.cpp.

References getLeft(), getRight(), getType(), mpLeft, mpRight, and mType.

{
  if (this->mpLeft != NULL) delete this->mpLeft;
  if (this->mpRight != NULL) delete this->mpRight;
  this->mType = src.getType();
  this->mpLeft = new CNormalFraction(src.getLeft());
  this->mpRight = new CNormalFraction(src.getRight());
  return *this;
}

bool CNormalGeneralPower::operator==

(

const CNormalGeneralPower &

rhs

)

const

Definition at line 140 of file CNormalGeneralPower.cpp.

References mpLeft, mpRight, and mType.

  {
    return ((this->mType == rhs.mType) && (*this->mpLeft) == (*rhs.mpLeft) && (*this->mpRight) == (*rhs.mpRight));
  }

void CNormalGeneralPower::setLeft

(

const CNormalFraction &

left

)

Definition at line 102 of file CNormalGeneralPower.cpp.

References mpLeft.

Referenced by createGeneralPower(), CNormalProduct::getDenominator(), multiply(), CNormalSum::simplify(), and test_simplify::test_simplify_1().

{
  if (this->mpLeft != NULL) delete this->mpLeft;
  this->mpLeft = new CNormalFraction(left);
}

void CNormalGeneralPower::setRight

(

const CNormalFraction &

right

)

Definition at line 118 of file CNormalGeneralPower.cpp.

References mpRight.

Referenced by createGeneralPower(), CNormalProduct::getDenominator(), multiply(), and test_simplify::test_simplify_1().

{
  if (this->mpRight != NULL) delete this->mpRight;
  this->mpRight = new CNormalFraction(right);
}

void CNormalGeneralPower::setType

(

CNormalGeneralPower::Type

type

)

Definition at line 129 of file CNormalGeneralPower.cpp.

References mType.

Referenced by createGeneralPower(), createUnitGeneralPower(), CNormalProduct::getDenominator(), multiply(), and test_simplify::test_simplify_1().

{
  this->mType = type;
}

bool CNormalGeneralPower::simplify ( )

virtual

Implements CNormalBase.

Definition at line 166 of file CNormalGeneralPower.cpp.

References mpLeft, mpRight, and CNormalFraction::simplify().

Referenced by test_simplify::test_simplify_1().

{
  bool result = true;
  if (this->mpLeft != NULL && this->mpRight != NULL)
    {
      result = (this->mpLeft->simplify() && this->mpRight->simplify());
    }
  return result;
}

std::string CNormalGeneralPower::toString ( ) const

virtual

Implements CNormalBase.

Definition at line 56 of file CNormalGeneralPower.cpp.

References CNormalFraction::checkDenominatorOne(), CNormalSum::checkIsOne(), CNormalFraction::getDenominator(), CNormalFraction::getNumerator(), INVALID, mpLeft, mpRight, mType, and SYMBOLS.

Referenced by operator<<().

  {
    std::ostringstream s;
    if (this->mType != INVALID)
      {
        // if the exponent is not 1, we have to add parentheses around the left
        // side, otherwise we don't
        // we check the numerator and the denominator separately because if they
        // are both equal bot not 1, we want to display the actual fraction not the
        // canceled fraction
        if (!(this->mpRight->getNumerator().checkIsOne() && this->mpRight->getDenominator().checkIsOne()))
          {
            s << "(" << *this->mpLeft << ")";
            s << CNormalGeneralPower::SYMBOLS[this->mType] << "(" << *this->mpRight << ")";
          }
        else
          {
            // we also have to addd parentesis if the denominator of the left
            // side is 1
            if (this->mpLeft->checkDenominatorOne())
              {
                s << "(" << *this->mpLeft << ")";
              }
            else
              {
                s << *this->mpLeft;
              }
          }
      }
    else
      {
        s << "(!!!INVALID GENERAL POWER!!!)";
      }
    return s.str();
  }

Member Data Documentation

CNormalFraction* CNormalGeneralPower::mpLeft

protected

Definition at line 40 of file CNormalGeneralPower.h.

Referenced by checkIsOne(), createUnitGeneralPower(), getLeft(), multiply(), operator<(), operator=(), operator==(), setLeft(), simplify(), toString(), and ~CNormalGeneralPower().

CNormalFraction* CNormalGeneralPower::mpRight

protected

Definition at line 41 of file CNormalGeneralPower.h.

Referenced by checkIsOne(), createUnitGeneralPower(), getRight(), multiply(), operator<(), operator=(), operator==(), setRight(), simplify(), toString(), and ~CNormalGeneralPower().

Type CNormalGeneralPower::mType

protected

Definition at line 39 of file CNormalGeneralPower.h.

Referenced by getType(), operator<(), operator=(), operator==(), setType(), and toString().

const char * CNormalGeneralPower::SYMBOLS = {"^", "%"}

staticprotected

Definition at line 43 of file CNormalGeneralPower.h.

Referenced by toString().

---

The documentation for this class was generated from the following files:

• CNormalGeneralPower.h
• CNormalGeneralPower.cpp