mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
177 lines
5.1 KiB
177 lines
5.1 KiB
/* SPDX-License-Identifier: GPL-2.0 */ |
|
#ifndef _LINUX_MATH_H |
|
#define _LINUX_MATH_H |
|
|
|
#include <asm/div64.h> |
|
#include <uapi/linux/kernel.h> |
|
|
|
/* |
|
* This looks more complex than it should be. But we need to |
|
* get the type for the ~ right in round_down (it needs to be |
|
* as wide as the result!), and we want to evaluate the macro |
|
* arguments just once each. |
|
*/ |
|
#define __round_mask(x, y) ((__typeof__(x))((y)-1)) |
|
|
|
/** |
|
* round_up - round up to next specified power of 2 |
|
* @x: the value to round |
|
* @y: multiple to round up to (must be a power of 2) |
|
* |
|
* Rounds @x up to next multiple of @y (which must be a power of 2). |
|
* To perform arbitrary rounding up, use roundup() below. |
|
*/ |
|
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1) |
|
|
|
/** |
|
* round_down - round down to next specified power of 2 |
|
* @x: the value to round |
|
* @y: multiple to round down to (must be a power of 2) |
|
* |
|
* Rounds @x down to next multiple of @y (which must be a power of 2). |
|
* To perform arbitrary rounding down, use rounddown() below. |
|
*/ |
|
#define round_down(x, y) ((x) & ~__round_mask(x, y)) |
|
|
|
#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP |
|
|
|
#define DIV_ROUND_DOWN_ULL(ll, d) \ |
|
({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; }) |
|
|
|
#define DIV_ROUND_UP_ULL(ll, d) \ |
|
DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d)) |
|
|
|
#if BITS_PER_LONG == 32 |
|
# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d) |
|
#else |
|
# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d) |
|
#endif |
|
|
|
/** |
|
* roundup - round up to the next specified multiple |
|
* @x: the value to up |
|
* @y: multiple to round up to |
|
* |
|
* Rounds @x up to next multiple of @y. If @y will always be a power |
|
* of 2, consider using the faster round_up(). |
|
*/ |
|
#define roundup(x, y) ( \ |
|
{ \ |
|
typeof(y) __y = y; \ |
|
(((x) + (__y - 1)) / __y) * __y; \ |
|
} \ |
|
) |
|
/** |
|
* rounddown - round down to next specified multiple |
|
* @x: the value to round |
|
* @y: multiple to round down to |
|
* |
|
* Rounds @x down to next multiple of @y. If @y will always be a power |
|
* of 2, consider using the faster round_down(). |
|
*/ |
|
#define rounddown(x, y) ( \ |
|
{ \ |
|
typeof(x) __x = (x); \ |
|
__x - (__x % (y)); \ |
|
} \ |
|
) |
|
|
|
/* |
|
* Divide positive or negative dividend by positive or negative divisor |
|
* and round to closest integer. Result is undefined for negative |
|
* divisors if the dividend variable type is unsigned and for negative |
|
* dividends if the divisor variable type is unsigned. |
|
*/ |
|
#define DIV_ROUND_CLOSEST(x, divisor)( \ |
|
{ \ |
|
typeof(x) __x = x; \ |
|
typeof(divisor) __d = divisor; \ |
|
(((typeof(x))-1) > 0 || \ |
|
((typeof(divisor))-1) > 0 || \ |
|
(((__x) > 0) == ((__d) > 0))) ? \ |
|
(((__x) + ((__d) / 2)) / (__d)) : \ |
|
(((__x) - ((__d) / 2)) / (__d)); \ |
|
} \ |
|
) |
|
/* |
|
* Same as above but for u64 dividends. divisor must be a 32-bit |
|
* number. |
|
*/ |
|
#define DIV_ROUND_CLOSEST_ULL(x, divisor)( \ |
|
{ \ |
|
typeof(divisor) __d = divisor; \ |
|
unsigned long long _tmp = (x) + (__d) / 2; \ |
|
do_div(_tmp, __d); \ |
|
_tmp; \ |
|
} \ |
|
) |
|
|
|
/* |
|
* Multiplies an integer by a fraction, while avoiding unnecessary |
|
* overflow or loss of precision. |
|
*/ |
|
#define mult_frac(x, numer, denom)( \ |
|
{ \ |
|
typeof(x) quot = (x) / (denom); \ |
|
typeof(x) rem = (x) % (denom); \ |
|
(quot * (numer)) + ((rem * (numer)) / (denom)); \ |
|
} \ |
|
) |
|
|
|
#define sector_div(a, b) do_div(a, b) |
|
|
|
/** |
|
* abs - return absolute value of an argument |
|
* @x: the value. If it is unsigned type, it is converted to signed type first. |
|
* char is treated as if it was signed (regardless of whether it really is) |
|
* but the macro's return type is preserved as char. |
|
* |
|
* Return: an absolute value of x. |
|
*/ |
|
#define abs(x) __abs_choose_expr(x, long long, \ |
|
__abs_choose_expr(x, long, \ |
|
__abs_choose_expr(x, int, \ |
|
__abs_choose_expr(x, short, \ |
|
__abs_choose_expr(x, char, \ |
|
__builtin_choose_expr( \ |
|
__builtin_types_compatible_p(typeof(x), char), \ |
|
(char)({ signed char __x = (x); __x<0?-__x:__x; }), \ |
|
((void)0))))))) |
|
|
|
#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \ |
|
__builtin_types_compatible_p(typeof(x), signed type) || \ |
|
__builtin_types_compatible_p(typeof(x), unsigned type), \ |
|
({ signed type __x = (x); __x < 0 ? -__x : __x; }), other) |
|
|
|
/** |
|
* reciprocal_scale - "scale" a value into range [0, ep_ro) |
|
* @val: value |
|
* @ep_ro: right open interval endpoint |
|
* |
|
* Perform a "reciprocal multiplication" in order to "scale" a value into |
|
* range [0, @ep_ro), where the upper interval endpoint is right-open. |
|
* This is useful, e.g. for accessing a index of an array containing |
|
* @ep_ro elements, for example. Think of it as sort of modulus, only that |
|
* the result isn't that of modulo. ;) Note that if initial input is a |
|
* small value, then result will return 0. |
|
* |
|
* Return: a result based on @val in interval [0, @ep_ro). |
|
*/ |
|
static inline u32 reciprocal_scale(u32 val, u32 ep_ro) |
|
{ |
|
return (u32)(((u64) val * ep_ro) >> 32); |
|
} |
|
|
|
u64 int_pow(u64 base, unsigned int exp); |
|
unsigned long int_sqrt(unsigned long); |
|
|
|
#if BITS_PER_LONG < 64 |
|
u32 int_sqrt64(u64 x); |
|
#else |
|
static inline u32 int_sqrt64(u64 x) |
|
{ |
|
return (u32)int_sqrt(x); |
|
} |
|
#endif |
|
|
|
#endif /* _LINUX_MATH_H */
|
|
|