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

/**

    27

 * Returns the maximum of two values.

    28

 *

    29

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

    30

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

    31

 *

    32

 * @param a The first value

    33

 * @param b The second value

    34

 * @return The greater value or a if equals

    35

 */

    36

template<typename T> static inline T max(const T a, const T b)

    37

{

    38

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

    39

}

    40

    41

/**

    42

 * Returns the minimum of two values.

    43

 *

    44

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

    45

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

    46

 *

    47

 * @param a The first value

    48

 * @param b The second value

    49

 * @return The smaller value or b if equals

    50

 */

    51

template<typename T> static inline T min(const T a, const T b)

    52

{

    53

	return (a < b) ? a : b;

    54

}

    55

    56

/**

    57

 * Returns the minimum of two integer.

    58

 *

    59

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

    60

 *

    61

 * @param a The first integer

    62

 * @param b The second integer

    63

 * @return The smaller value

    64

 */

    65

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

    66

{

    67

	return (a < b) ? a : b;

    68

}

    69

    70

/**

    71

 * Returns the minimum of two unsigned integers.

    72

 *

    73

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

    74

 *

    75

 * @param a The first unsigned integer

    76

 * @param b The second unsigned integer

    77

 * @return The smaller value

    78

 */

    79

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

    80

{

    81

	return (a < b) ? a : b;

    82

}

    83

    84

/**

    85

 * Returns the absolute value of (scalar) variable.

    86

 *

    87

 * @note assumes variable to be signed

    88

 * @param a The value we want to unsign

    89

 * @return The unsigned value

    90

 */

    91

template <typename T> static inline T abs(const T a)

    92

{

    93

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

    94

}

    95

    96

/**

    97

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

    98

 *

    99

 * @note n must be a power of 2

   100

 * @param x The min value

   101

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

   102

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

   103

 */

   104

template<typename T> static inline T Align(const T x, uint n)

   105

{

   106

	n--;

   107

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

   108

}

   109

   110

/**

   111

 * Clamp an integer between an interval.

   112

 *

   113

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

   114

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

   115

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

   116

 * which side of the interval was 'left'.

   117

 *

   118

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

   119

 *       unexpected results.

   120

 * @param a The value to clamp/truncate.

   121

 * @param min The minimum of the interval.

   122

 * @param max the maximum of the interval.

   123

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

   124

 * @see ClampU(uint, uint, uint)

   125

 */

   126

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

   127

{

   128

	if (a <= min) return min;

   129

	if (a >= max) return max;

   130

	return a;

   131

}

   132

   133

/**

   134

 * Clamp an unsigned integer between an interval.

   135

 *

   136

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

   137

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

   138

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

   139

 * which side of the interval was 'left'.

   140

 *

   141

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

   142

 *       unexpected results.

   143

 * @param a The value to clamp/truncate.

   144

 * @param min The minimum of the interval.

   145

 * @param max the maximum of the interval.

   146

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

   147

 * @see Clamp(int, int, int)

   148

 */

   149

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

   150

{

   151

	if (a <= min) return min;

   152

	if (a >= max) return max;

   153

	return a;

   154

}

   155

   156

/**

   157

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

   158

 *

   159

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

   160

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

   161

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

   162

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

   163

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

   164

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

   165

 *

   166

 * @param a The 64-bit value to clamps

   167

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

   168

 * @see Clamp(int, int, int)

   169

 */

   170

static inline int32 ClampToI32(const int64 a)

   171

{

   172

	if (a <= (int32)0x80000000) return 0x80000000;

   173

	if (a >= (int32)0x7FFFFFFF) return 0x7FFFFFFF;

   174

	return (int32)a;

   175

}

   176

   177

/**

   178

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

   179

 *

   180

 * @param a The first scalar

   181

 * @param b The second scalar

   182

 * @return The absolute difference between the given scalars

   183

 */

   184

template <typename T> static inline T Delta(const T a, const T b) {

   185

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

   186

}

   187

   188

/**

   189

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

   190

 *

   191

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

   192

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

   193

 * base+size this returns false.

   194

 *

   195

 * @param x The value to check

   196

 * @param base The base value of the interval

   197

 * @param size The size of the interval

   198

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

   199

 */

   200

template<typename T> static inline bool IsInsideBS(const T x, const uint base, const uint size)

   201

{

   202

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

   203

}

   204

   205

/**

   206

 * Checks if a value is in an interval.

   207

 *

   208

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

   209

 *

   210

 * @param a The value to check

   211

 * @param min The minimum of the interval

   212

 * @param max The maximum of the interval

   213

 * @see IsInsideBS()

   214

 */

   215

template<typename T> static inline bool IsInsideMM(const T x, const uint min, const uint max)

   216

{

   217

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

   218

}

   219

   220

#endif /* MATH_FUNC_HPP */