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

	assert((n & (n - 1)) == 0 && n != 0);

   105

	n--;

   106

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

   107

}

   108

   109

/**

   110

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

   111

 * Applies to pointers only

   112

 *

   113

 * @note n must be a power of 2

   114

 * @param x The min value

   115

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

   116

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

   117

 * @see Align()

   118

 */

   119

   120

assert_compile(sizeof(size_t) == sizeof(void *));

   121

   122

template <typename T>

   123

static FORCEINLINE T *AlignPtr(T *x, uint n)

   124

{

   125

	return (T *)Align((size_t)x, n);

   126

}

   127

   128

/**

   129

 * Clamp an integer between an interval.

   130

 *

   131

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

   132

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

   133

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

   134

 * which side of the interval was 'left'.

   135

 *

   136

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

   137

 *       unexpected results.

   138

 * @param a The value to clamp/truncate.

   139

 * @param min The minimum of the interval.

   140

 * @param max the maximum of the interval.

   141

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

   142

 * @see ClampU(uint, uint, uint)

   143

 */

   144

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

   145

{

   146

	if (a <= min) return min;

   147

	if (a >= max) return max;

   148

	return a;

   149

}

   150

   151

/**

   152

 * Clamp an unsigned integer between an interval.

   153

 *

   154

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

   155

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

   156

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

   157

 * which side of the interval was 'left'.

   158

 *

   159

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

   160

 *       unexpected results.

   161

 * @param a The value to clamp/truncate.

   162

 * @param min The minimum of the interval.

   163

 * @param max the maximum of the interval.

   164

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

   165

 * @see Clamp(int, int, int)

   166

 */

   167

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

   168

{

   169

	if (a <= min) return min;

   170

	if (a >= max) return max;

   171

	return a;

   172

}

   173

   174

/**

   175

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

   176

 *

   177

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

   178

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

   179

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

   180

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

   181

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

   182

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

   183

 *

   184

 * @param a The 64-bit value to clamps

   185

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

   186

 * @see Clamp(int, int, int)

   187

 */

   188

static FORCEINLINE int32 ClampToI32(const int64 a)

   189

{

   190

	if (a <= INT32_MIN) return INT32_MIN;

   191

	if (a >= INT32_MAX) return INT32_MAX;

   192

	return (int32)a;

   193

}

   194

   195

/**

   196

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

   197

 *

   198

 * @param a The 64-bit value to clamp

   199

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

   200

 * @see ClampU(uint, uint, uint)

   201

 */

   202

static FORCEINLINE uint16 ClampToU16(const uint64 a)

   203

{

   204

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

   205

}

   206

   207

/**

   208

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

   209

 *

   210

 * @param a The first scalar

   211

 * @param b The second scalar

   212

 * @return The absolute difference between the given scalars

   213

 */

   214

template <typename T>

   215

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

   216

{

   217

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

   218

}

   219

   220

/**

   221

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

   222

 *

   223

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

   224

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

   225

 * base+size this returns false.

   226

 *

   227

 * @param x The value to check

   228

 * @param base The base value of the interval

   229

 * @param size The size of the interval

   230

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

   231

 */

   232

template <typename T>

   233

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

   234

{

   235

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

   236

}

   237

   238

/**

   239

 * Checks if a value is in an interval.

   240

 *

   241

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

   242

 *

   243

 * @param a The value to check

   244

 * @param min The minimum of the interval

   245

 * @param max The maximum of the interval

   246

 * @see IsInsideBS()

   247

 */

   248

template <typename T>

   249

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

   250

{

   251

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

   252

}

   253

   254

/**

   255

 * Type safe swap operation

   256

 * @param a variable to swap with b

   257

 * @param b variable to swap with a

   258

 */

   259

template <typename T>

   260

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

   261

{

   262

	T t = a;

   263

	a = b;

   264

	b = t;

   265

}

   266

   267

#endif /* MATH_FUNC_HPP */