1

/* $Id$ */

     2

     3

/** @file math_func.hpp Integer math functions */

     4

     5

#ifndef MATH_FUNC_HPP

     6

#define MATH_FUNC_HPP

     7

     8

#ifdef min

     9

#undef min

    10

#endif

    11

    12

#ifdef max

    13

#undef max

    14

#endif

    15

    16

#ifdef abs

    17

#undef abs

    18

#endif

    19

    20

/**

    21

 * Returns the maximum of two values.

    22

 *

    23

 * This function returns the greater value of two given values.

    24

 * If they are equal the value of a is returned.

    25

 *

    26

 * @param a The first value

    27

 * @param b The second value

    28

 * @return The greater value or a if equals

    29

 */

    30

template <typename T>

    31

static FORCEINLINE T max(const T a, const T b)

    32

{

    33

	return (a >= b) ? a : b;

    34

}

    35

    36

/**

    37

 * Returns the minimum of two values.

    38

 *

    39

 * This function returns the smaller value of two given values.

    40

 * If they are equal the value of b is returned.

    41

 *

    42

 * @param a The first value

    43

 * @param b The second value

    44

 * @return The smaller value or b if equals

    45

 */

    46

template <typename T>

    47

static FORCEINLINE T min(const T a, const T b)

    48

{

    49

	return (a < b) ? a : b;

    50

}

    51

    52

/**

    53

 * Returns the minimum of two integer.

    54

 *

    55

 * This function returns the smaller value of two given integers.

    56

 *

    57

 * @param a The first integer

    58

 * @param b The second integer

    59

 * @return The smaller value

    60

 */

    61

static FORCEINLINE int min(const int a, const int b)

    62

{

    63

	return (a < b) ? a : b;

    64

}

    65

    66

/**

    67

 * Returns the minimum of two unsigned integers.

    68

 *

    69

 * This function returns the smaller value of two given unsigned integers.

    70

 *

    71

 * @param a The first unsigned integer

    72

 * @param b The second unsigned integer

    73

 * @return The smaller value

    74

 */

    75

static FORCEINLINE uint minu(const uint a, const uint b)

    76

{

    77

	return (a < b) ? a : b;

    78

}

    79

    80

/**

    81

 * Returns the absolute value of (scalar) variable.

    82

 *

    83

 * @note assumes variable to be signed

    84

 * @param a The value we want to unsign

    85

 * @return The unsigned value

    86

 */

    87

template <typename T>

    88

static FORCEINLINE T abs(const T a)

    89

{

    90

	return (a < (T)0) ? -a : a;

    91

}

    92

    93

/**

    94

 * Return the smallest multiple of n equal or greater than x

    95

 *

    96

 * @note n must be a power of 2

    97

 * @param x The min value

    98

 * @param n The base of the number we are searching

    99

 * @return The smallest multiple of n equal or greater than x

   100

 */

   101

template <typename T>

   102

static FORCEINLINE T Align(const T x, uint n)

   103

{

   104

	n--;

   105

	return (T)((x + n) & ~(n));

   106

}

   107

   108

/**

   109

 * Clamp an integer between an interval.

   110

 *

   111

 * This function returns a value which is between the given interval of

   112

 * min and max. If the given value is in this interval the value itself

   113

 * is returned otherwise the border of the interval is returned, according

   114

 * which side of the interval was 'left'.

   115

 *

   116

 * @note The min value must be less or equal of max or you get some

   117

 *       unexpected results.

   118

 * @param a The value to clamp/truncate.

   119

 * @param min The minimum of the interval.

   120

 * @param max the maximum of the interval.

   121

 * @returns A value between min and max which is closest to a.

   122

 * @see ClampU(uint, uint, uint)

   123

 */

   124

static FORCEINLINE int Clamp(const int a, const int min, const int max)

   125

{

   126

	if (a <= min) return min;

   127

	if (a >= max) return max;

   128

	return a;

   129

}

   130

   131

/**

   132

 * Clamp an unsigned integer between an interval.

   133

 *

   134

 * This function returns a value which is between the given interval of

   135

 * min and max. If the given value is in this interval the value itself

   136

 * is returned otherwise the border of the interval is returned, according

   137

 * which side of the interval was 'left'.

   138

 *

   139

 * @note The min value must be less or equal of max or you get some

   140

 *       unexpected results.

   141

 * @param a The value to clamp/truncate.

   142

 * @param min The minimum of the interval.

   143

 * @param max the maximum of the interval.

   144

 * @returns A value between min and max which is closest to a.

   145

 * @see Clamp(int, int, int)

   146

 */

   147

static FORCEINLINE uint ClampU(const uint a, const uint min, const uint max)

   148

{

   149

	if (a <= min) return min;

   150

	if (a >= max) return max;

   151

	return a;

   152

}

   153

   154

/**

   155

 * Reduce a signed 64-bit int to a signed 32-bit one

   156

 *

   157

 * This function clamps a 64-bit integer to a 32-bit integer.

   158

 * If the 64-bit value is smaller than the smallest 32-bit integer

   159

 * value 0x80000000 this value is returned (the left one bit is the sign bit).

   160

 * If the 64-bit value is greater than the greatest 32-bit integer value 0x7FFFFFFF

   161

 * this value is returned. In all other cases the 64-bit value 'fits' in a

   162

 * 32-bits integer field and so the value is casted to int32 and returned.

   163

 *

   164

 * @param a The 64-bit value to clamps

   165

 * @return The 64-bit value reduced to a 32-bit value

   166

 * @see Clamp(int, int, int)

   167

 */

   168

static FORCEINLINE int32 ClampToI32(const int64 a)

   169

{

   170

	if (a <= INT32_MIN) return INT32_MIN;

   171

	if (a >= INT32_MAX) return INT32_MAX;

   172

	return (int32)a;

   173

}

   174

   175

/**

   176

 * Reduce an unsigned 64-bit int to an unsigned 16-bit one

   177

 *

   178

 * @param a The 64-bit value to clamp

   179

 * @return The 64-bit value reduced to a 16-bit value

   180

 * @see ClampU(uint, uint, uint)

   181

 */

   182

static FORCEINLINE uint16 ClampToU16(const uint64 a)

   183

{

   184

	return (uint16)(a <= UINT16_MAX ? a : UINT16_MAX);

   185

}

   186

   187

/**

   188

 * Returns the (absolute) difference between two (scalar) variables

   189

 *

   190

 * @param a The first scalar

   191

 * @param b The second scalar

   192

 * @return The absolute difference between the given scalars

   193

 */

   194

template <typename T>

   197

	return (a < b) ? b - a : a - b;

   198

}

   199

   200

/**

   201

 * Checks if a value is between a window started at some base point.

   202

 *

   203

 * This function checks if the value x is between the value of base

   204

 * and base+size. If x equals base this returns true. If x equals

   205

 * base+size this returns false.

   206

 *

   207

 * @param x The value to check

   208

 * @param base The base value of the interval

   209

 * @param size The size of the interval

   210

 * @return True if the value is in the interval, false else.

   211

 */

   212

template <typename T>

   213

static FORCEINLINE bool IsInsideBS(const T x, const uint base, const uint size)

   214

{

   215

	return (uint)(x - base) < size;

   216

}

   217

   218

/**

   219

 * Checks if a value is in an interval.

   220

 *

   221

 * Returns true if a value is in the interval of [min, max).

   222

 *

   223

 * @param a The value to check

   224

 * @param min The minimum of the interval

   225

 * @param max The maximum of the interval

   226

 * @see IsInsideBS()

   227

 */

   228

template <typename T>

   229

static FORCEINLINE bool IsInsideMM(const T x, const uint min, const uint max)

   230

{

   231

	return (uint)(x - min) < (max - min);

   232

}

   233

   234

/**

   235

 * Type safe swap operation

   236

 * @param a variable to swap with b

   237

 * @param b variable to swap with a

   238

 */

   239

template <typename T>

   240

static FORCEINLINE void Swap(T &a, T &b)

   241

{

   242

	T t = a;

   243

	a = b;

   244

	b = t;

   245

}

   246

   247

#endif /* MATH_FUNC_HPP */