short.hpp

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

  Beagle_StackTraceEndM("Short operator++(Short& inShort, int)");
}


/*!
 *  \brief Add two Short.
 *  \param inLeftShort Left value to add.
 *  \param inRightShort Right value to add.
 *  \return Result of the addition.
 */
inline
Beagle::Short operator+(const Beagle::Short& inLeftShort, const Beagle::Short& inRightShort)
{
  Beagle_StackTraceBeginM();
  return inLeftShort.getWrappedValue() + inRightShort.getWrappedValue();
  Beagle_StackTraceEndM("Short operator+(const Short& inLeftShort, const Short& inRightShort)");
}


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


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


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


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


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



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


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


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


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


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


/*!
 *  \brief Multiply a Short with a short.
 *  \param inLeftShort Left value to multiply.
 *  \param inRightShort Right value to multiply.
 *  \return Result of the multiply.
 */
inline
Beagle::Short operator*(const Beagle::Short& inLeftShort, short inRightShort)
{
  Beagle_StackTraceBeginM();
  return inLeftShort.getWrappedValue() * inRightShort;
  Beagle_StackTraceEndM("Short operator*(const Short& inLeftShort, short inRightShort)");
}


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


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


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


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


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


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


#endif // Beagle_Short_hpp