uchar.hpp

非常好的进化算法EC 实现平台 可以实现多种算法 GA GP

Beagle::UChar operator+(const Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() + inRightUChar.getWrappedValue();
  Beagle_StackTraceEndM("UChar operator+(const UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Add a UChar with a unsigned char.
 *  \param inLeftUChar Left value to add.
 *  \param inRightUChar Right value to add.
 *  \return Result of the addition.
 */
inline
Beagle::UChar operator+(const Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() + inRightUChar;
  Beagle_StackTraceEndM("UChar operator+(const Beagle::UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Add a UChar to a UChar.
 *  \param inLeftUChar Left value to which the right one is added.
 *  \param inRightUChar Value to add.
 *  \return Result of the addition.
 */
inline
Beagle::UChar& operator+=(Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() += inRightUChar.getWrappedValue();
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator+=(UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Add a unsigned char to a UChar.
 *  \param inLeftUChar Left value to which the right one is added.
 *  \param inRightUChar Value to add.
 *  \return Result of the addition.
 */
inline
Beagle::UChar& operator+=(Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() += inRightUChar;
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator+=(UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Decrement a UChar (prefix version).
 *  \param inUChar UChar to decrement.
 *  \return UChar decremented.
 */
inline
Beagle::UChar& operator--(Beagle::UChar& inUChar)
{
  Beagle_StackTraceBeginM();
  inUChar.getWrappedValue()--;
  return inUChar;
  Beagle_StackTraceEndM("UChar& operator--(UChar& inUChar)");
}


/*!
 *  \brief Decrement a UChar (postfix version).
 *  \param inUChar UChar to decrement.
 *  \return UChar before being decremented.
 */
inline
Beagle::UChar operator--(Beagle::UChar& inUChar, int)
{
  Beagle_StackTraceBeginM();
  Beagle::UChar lUChar = inUChar;
  inUChar.getWrappedValue()--;
  return lUChar;
  Beagle_StackTraceEndM("UChar operator--(UChar& inUChar, int)");
}



/*!
 *  \brief Subtract two UChar.
 *  \param inLeftUChar Left value to subtract.
 *  \param inRightUChar Right value to subtract.
 *  \return Result of the subtract.
 */
inline
Beagle::UChar operator-(const Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() - inRightUChar.getWrappedValue();
  Beagle_StackTraceEndM("UChar operator-(const UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Subtract a unsigned char from a UChar.
 *  \param inLeftUChar Left value to subtract.
 *  \param inRightUChar Right value to subtract.
 *  \return Result of the subtract.
 */
inline
Beagle::UChar operator-(const Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() - inRightUChar;
  Beagle_StackTraceEndM("UChar operator-(const UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Subtract a UChar from a UChar.
 *  \param inLeftUChar Left value from which the right unsigned char is subtracted.
 *  \param inRightUChar Value to subtract.
 *  \return Result of the subtraction.
 */
inline
Beagle::UChar& operator-=(Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() -= inRightUChar.getWrappedValue();
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator-=(UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Subtract a unsigned char from a UChar.
 *  \param inLeftUChar Left value from which the right unsigned char is subtracted.
 *  \param inRightUChar Value to subtract.
 *  \return Result of the subtraction.
 */
inline
Beagle::UChar& operator-=(Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() -= inRightUChar;
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator-=(UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Multiply two UChar.
 *  \param inLeftUChar Left value to multiply.
 *  \param inRightUChar Right value to multiply.
 *  \return Result of the multiply.
 */
inline
Beagle::UChar operator*(const Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() * inRightUChar.getWrappedValue();
  Beagle_StackTraceEndM("UChar operator*(const UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Multiply a UChar with a unsigned char.
 *  \param inLeftUChar Left value to multiply.
 *  \param inRightUChar Right value to multiply.
 *  \return Result of the multiply.
 */
inline
Beagle::UChar operator*(const Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() * inRightUChar;
  Beagle_StackTraceEndM("UChar operator*(const UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Multiply a UChar with a UChar.
 *  \param inLeftUChar Left value to which the right unsigned char is multiplied.
 *  \param inRightUChar Right value to multiply.
 *  \return Result of the multiplication.
 */
inline
Beagle::UChar& operator*=(Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() *= inRightUChar.getWrappedValue();
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator*=(UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Multiply a UChar with a unsigned char.
 *  \param inLeftUChar Left value from which the right unsigned char is multiplied.
 *  \param inRightUChar Right value to multiply.
 *  \return Result of the multiplication.
 */
inline
Beagle::UChar& operator*=(Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() *= inRightUChar;
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator*=(UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Divide two UChar.
 *  \param inLeftUChar Left value to divide.
 *  \param inRightUChar Right value to divide.
 *  \return Result of the division.
 */
inline
Beagle::UChar operator/(const Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() / inRightUChar.getWrappedValue();
  Beagle_StackTraceEndM("UChar operator/(const UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Divide a UChar with a unsigned char.
 *  \param inLeftUChar Left value to divide.
 *  \param inRightUChar Right value to divide.
 *  \return Result of the division.
 */
inline
Beagle::UChar operator/(const Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  return inLeftUChar.getWrappedValue() / inRightUChar;
  Beagle_StackTraceEndM("UChar operator/(const UChar& inLeftUChar, unsigned char inRightUChar)");
}


/*!
 *  \brief Divide a UChar with a UChar.
 *  \param inLeftUChar Left value to which the right unsigned char is divided.
 *  \param inRightUChar Right value to divide.
 *  \return Result of the division.
 */
inline
Beagle::UChar& operator/=(Beagle::UChar& inLeftUChar, const Beagle::UChar& inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() /= inRightUChar.getWrappedValue();
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar& operator/=(UChar& inLeftUChar, const UChar& inRightUChar)");
}


/*!
 *  \brief Divide a UChar with a unsigned char.
 *  \param inLeftUChar Left value from which the right unsigned char is divided.
 *  \param inRightUChar Right value to divide.
 *  \return Result of the division.
 */
inline
Beagle::UChar operator/=(Beagle::UChar& inLeftUChar, unsigned char inRightUChar)
{
  Beagle_StackTraceBeginM();
  inLeftUChar.getWrappedValue() /= inRightUChar;
  return inLeftUChar;
  Beagle_StackTraceEndM("UChar operator/=(UChar& inLeftUChar, unsigned char inRightUChar)");
}


#endif // Beagle_UChar_hpp