int.hpp

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

  Beagle_StackTraceEndM("Int operator++(Int& inInt, int)");
}


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


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


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


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


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


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



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


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


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


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


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


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


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


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


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


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


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


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


#endif // Beagle_Int_hpp