float.hpp

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

  return inLeftFloat.getWrappedValue() >= inRightFloat;
  Beagle_StackTraceEndM("bool operator>=(const Float& inLeftFloat, float inRightFloat)");
}


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


#endif // Beagle_Float_hpp