Line data Source code
1 : /* SPDX-License-Identifier: GPL-2.0 */
2 : #ifndef _LINUX_MATH_H
3 : #define _LINUX_MATH_H
4 :
5 : #include <asm/div64.h>
6 : #include <uapi/linux/kernel.h>
7 :
8 : /*
9 : * This looks more complex than it should be. But we need to
10 : * get the type for the ~ right in round_down (it needs to be
11 : * as wide as the result!), and we want to evaluate the macro
12 : * arguments just once each.
13 : */
14 : #define __round_mask(x, y) ((__typeof__(x))((y)-1))
15 :
16 : /**
17 : * round_up - round up to next specified power of 2
18 : * @x: the value to round
19 : * @y: multiple to round up to (must be a power of 2)
20 : *
21 : * Rounds @x up to next multiple of @y (which must be a power of 2).
22 : * To perform arbitrary rounding up, use roundup() below.
23 : */
24 : #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
25 :
26 : /**
27 : * round_down - round down to next specified power of 2
28 : * @x: the value to round
29 : * @y: multiple to round down to (must be a power of 2)
30 : *
31 : * Rounds @x down to next multiple of @y (which must be a power of 2).
32 : * To perform arbitrary rounding down, use rounddown() below.
33 : */
34 : #define round_down(x, y) ((x) & ~__round_mask(x, y))
35 :
36 : #define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
37 :
38 : #define DIV_ROUND_DOWN_ULL(ll, d) \
39 : ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
40 :
41 : #define DIV_ROUND_UP_ULL(ll, d) \
42 : DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))
43 :
44 : #if BITS_PER_LONG == 32
45 : # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
46 : #else
47 : # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
48 : #endif
49 :
50 : /**
51 : * roundup - round up to the next specified multiple
52 : * @x: the value to up
53 : * @y: multiple to round up to
54 : *
55 : * Rounds @x up to next multiple of @y. If @y will always be a power
56 : * of 2, consider using the faster round_up().
57 : */
58 : #define roundup(x, y) ( \
59 : { \
60 : typeof(y) __y = y; \
61 : (((x) + (__y - 1)) / __y) * __y; \
62 : } \
63 : )
64 : /**
65 : * rounddown - round down to next specified multiple
66 : * @x: the value to round
67 : * @y: multiple to round down to
68 : *
69 : * Rounds @x down to next multiple of @y. If @y will always be a power
70 : * of 2, consider using the faster round_down().
71 : */
72 : #define rounddown(x, y) ( \
73 : { \
74 : typeof(x) __x = (x); \
75 : __x - (__x % (y)); \
76 : } \
77 : )
78 :
79 : /*
80 : * Divide positive or negative dividend by positive or negative divisor
81 : * and round to closest integer. Result is undefined for negative
82 : * divisors if the dividend variable type is unsigned and for negative
83 : * dividends if the divisor variable type is unsigned.
84 : */
85 : #define DIV_ROUND_CLOSEST(x, divisor)( \
86 : { \
87 : typeof(x) __x = x; \
88 : typeof(divisor) __d = divisor; \
89 : (((typeof(x))-1) > 0 || \
90 : ((typeof(divisor))-1) > 0 || \
91 : (((__x) > 0) == ((__d) > 0))) ? \
92 : (((__x) + ((__d) / 2)) / (__d)) : \
93 : (((__x) - ((__d) / 2)) / (__d)); \
94 : } \
95 : )
96 : /*
97 : * Same as above but for u64 dividends. divisor must be a 32-bit
98 : * number.
99 : */
100 : #define DIV_ROUND_CLOSEST_ULL(x, divisor)( \
101 : { \
102 : typeof(divisor) __d = divisor; \
103 : unsigned long long _tmp = (x) + (__d) / 2; \
104 : do_div(_tmp, __d); \
105 : _tmp; \
106 : } \
107 : )
108 :
109 : /*
110 : * Multiplies an integer by a fraction, while avoiding unnecessary
111 : * overflow or loss of precision.
112 : */
113 : #define mult_frac(x, numer, denom)( \
114 : { \
115 : typeof(x) quot = (x) / (denom); \
116 : typeof(x) rem = (x) % (denom); \
117 : (quot * (numer)) + ((rem * (numer)) / (denom)); \
118 : } \
119 : )
120 :
121 : #define sector_div(a, b) do_div(a, b)
122 :
123 : /**
124 : * abs - return absolute value of an argument
125 : * @x: the value. If it is unsigned type, it is converted to signed type first.
126 : * char is treated as if it was signed (regardless of whether it really is)
127 : * but the macro's return type is preserved as char.
128 : *
129 : * Return: an absolute value of x.
130 : */
131 : #define abs(x) __abs_choose_expr(x, long long, \
132 : __abs_choose_expr(x, long, \
133 : __abs_choose_expr(x, int, \
134 : __abs_choose_expr(x, short, \
135 : __abs_choose_expr(x, char, \
136 : __builtin_choose_expr( \
137 : __builtin_types_compatible_p(typeof(x), char), \
138 : (char)({ signed char __x = (x); __x<0?-__x:__x; }), \
139 : ((void)0)))))))
140 :
141 : #define __abs_choose_expr(x, type, other) __builtin_choose_expr( \
142 : __builtin_types_compatible_p(typeof(x), signed type) || \
143 : __builtin_types_compatible_p(typeof(x), unsigned type), \
144 : ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
145 :
146 : /**
147 : * reciprocal_scale - "scale" a value into range [0, ep_ro)
148 : * @val: value
149 : * @ep_ro: right open interval endpoint
150 : *
151 : * Perform a "reciprocal multiplication" in order to "scale" a value into
152 : * range [0, @ep_ro), where the upper interval endpoint is right-open.
153 : * This is useful, e.g. for accessing a index of an array containing
154 : * @ep_ro elements, for example. Think of it as sort of modulus, only that
155 : * the result isn't that of modulo. ;) Note that if initial input is a
156 : * small value, then result will return 0.
157 : *
158 : * Return: a result based on @val in interval [0, @ep_ro).
159 : */
160 33 : static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
161 : {
162 33 : return (u32)(((u64) val * ep_ro) >> 32);
163 : }
164 :
165 : u64 int_pow(u64 base, unsigned int exp);
166 : unsigned long int_sqrt(unsigned long);
167 :
168 : #if BITS_PER_LONG < 64
169 : u32 int_sqrt64(u64 x);
170 : #else
171 : static inline u32 int_sqrt64(u64 x)
172 : {
173 : return (u32)int_sqrt(x);
174 : }
175 : #endif
176 :
177 : #endif /* _LINUX_MATH_H */
|
