Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_MATH_H
3#define _LINUX_MATH_H
4
5#include <linux/types.h>
6#include <asm/div64.h>
7#include <uapi/linux/kernel.h>
8
9/*
10 * This looks more complex than it should be. But we need to
11 * get the type for the ~ right in round_down (it needs to be
12 * as wide as the result!), and we want to evaluate the macro
13 * arguments just once each.
14 */
15#define __round_mask(x, y) ((__typeof__(x))((y)-1))
16
17/**
18 * round_up - round up to next specified power of 2
19 * @x: the value to round
20 * @y: multiple to round up to (must be a power of 2)
21 *
22 * Rounds @x up to next multiple of @y (which must be a power of 2).
23 * To perform arbitrary rounding up, use roundup() below.
24 */
25#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
26
27/**
28 * round_down - round down to next specified power of 2
29 * @x: the value to round
30 * @y: multiple to round down to (must be a power of 2)
31 *
32 * Rounds @x down to next multiple of @y (which must be a power of 2).
33 * To perform arbitrary rounding down, use rounddown() below.
34 */
35#define round_down(x, y) ((x) & ~__round_mask(x, y))
36
37/**
38 * DIV_ROUND_UP_POW2 - divide and round up
39 * @n: numerator
40 * @d: denominator (must be a power of 2)
41 *
42 * Divides @n by @d and rounds up to next multiple of @d (which must be a power
43 * of 2). Avoids integer overflows that may occur with __KERNEL_DIV_ROUND_UP().
44 * Performance is roughly equivalent to __KERNEL_DIV_ROUND_UP().
45 */
46#define DIV_ROUND_UP_POW2(n, d) \
47 ((n) / (d) + !!((n) & ((d) - 1)))
48
49#define DIV_ROUND_UP __KERNEL_DIV_ROUND_UP
50
51#define DIV_ROUND_DOWN_ULL(ll, d) \
52 ({ unsigned long long _tmp = (ll); do_div(_tmp, d); _tmp; })
53
54#define DIV_ROUND_UP_ULL(ll, d) \
55 DIV_ROUND_DOWN_ULL((unsigned long long)(ll) + (d) - 1, (d))
56
57#if BITS_PER_LONG == 32
58# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP_ULL(ll, d)
59#else
60# define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
61#endif
62
63/**
64 * roundup - round up to the next specified multiple
65 * @x: the value to up
66 * @y: multiple to round up to
67 *
68 * Rounds @x up to next multiple of @y. If @y will always be a power
69 * of 2, consider using the faster round_up().
70 */
71#define roundup(x, y) ( \
72{ \
73 typeof(y) __y = y; \
74 (((x) + (__y - 1)) / __y) * __y; \
75} \
76)
77/**
78 * rounddown - round down to next specified multiple
79 * @x: the value to round
80 * @y: multiple to round down to
81 *
82 * Rounds @x down to next multiple of @y. If @y will always be a power
83 * of 2, consider using the faster round_down().
84 */
85#define rounddown(x, y) ( \
86{ \
87 typeof(x) __x = (x); \
88 __x - (__x % (y)); \
89} \
90)
91
92#define DIV_ROUND_CLOSEST __KERNEL_DIV_ROUND_CLOSEST
93/*
94 * Same as above but for u64 dividends. divisor must be a 32-bit
95 * number.
96 */
97#define DIV_ROUND_CLOSEST_ULL(x, divisor)( \
98{ \
99 typeof(divisor) __d = divisor; \
100 unsigned long long _tmp = (x) + (__d) / 2; \
101 do_div(_tmp, __d); \
102 _tmp; \
103} \
104)
105
106#define __STRUCT_FRACT(type) \
107struct type##_fract { \
108 __##type numerator; \
109 __##type denominator; \
110};
111__STRUCT_FRACT(s8)
112__STRUCT_FRACT(u8)
113__STRUCT_FRACT(s16)
114__STRUCT_FRACT(u16)
115__STRUCT_FRACT(s32)
116__STRUCT_FRACT(u32)
117#undef __STRUCT_FRACT
118
119/* Calculate "x * n / d" without unnecessary overflow or loss of precision. */
120#define mult_frac(x, n, d) \
121({ \
122 typeof(x) x_ = (x); \
123 typeof(n) n_ = (n); \
124 typeof(d) d_ = (d); \
125 \
126 typeof(x_) q = x_ / d_; \
127 typeof(x_) r = x_ % d_; \
128 q * n_ + r * n_ / d_; \
129})
130
131#define sector_div(a, b) do_div(a, b)
132
133/**
134 * abs - return absolute value of an argument
135 * @x: the value.
136 *
137 * If it is unsigned type, @x is converted to signed type first.
138 * char is treated as if it was signed (regardless of whether it really is)
139 * but the macro's return type is preserved as char.
140 *
141 * NOTE, for signed type if @x is the minimum, the returned result is undefined
142 * as there is not enough bits to represent it as a positive number.
143 *
144 * Return: an absolute value of @x.
145 */
146#define abs(x) __abs_choose_expr(x, long long, \
147 __abs_choose_expr(x, long, \
148 __abs_choose_expr(x, int, \
149 __abs_choose_expr(x, short, \
150 __abs_choose_expr(x, char, \
151 __builtin_choose_expr( \
152 __builtin_types_compatible_p(typeof(x), char), \
153 (char)({ signed char __x = (x); __x<0?-__x:__x; }), \
154 ((void)0)))))))
155
156#define __abs_choose_expr(x, type, other) __builtin_choose_expr( \
157 __builtin_types_compatible_p(typeof(x), signed type) || \
158 __builtin_types_compatible_p(typeof(x), unsigned type), \
159 ({ signed type __x = (x); __x < 0 ? -__x : __x; }), other)
160
161/**
162 * abs_diff - return absolute value of the difference between the arguments
163 * @a: the first argument
164 * @b: the second argument
165 *
166 * @a and @b have to be of the same type. With this restriction we compare
167 * signed to signed and unsigned to unsigned. The result is the subtraction
168 * the smaller of the two from the bigger, hence result is always a positive
169 * value.
170 *
171 * Return: an absolute value of the difference between the @a and @b.
172 */
173#define abs_diff(a, b) ({ \
174 typeof(a) __a = (a); \
175 typeof(b) __b = (b); \
176 (void)(&__a == &__b); \
177 __a > __b ? (__a - __b) : (__b - __a); \
178})
179
180/**
181 * reciprocal_scale - "scale" a value into range [0, ep_ro)
182 * @val: value
183 * @ep_ro: right open interval endpoint
184 *
185 * Perform a "reciprocal multiplication" in order to "scale" a value into
186 * range [0, @ep_ro), where the upper interval endpoint is right-open.
187 * This is useful, e.g. for accessing a index of an array containing
188 * @ep_ro elements, for example. Think of it as sort of modulus, only that
189 * the result isn't that of modulo. ;) Note that if initial input is a
190 * small value, then result will return 0.
191 *
192 * Return: a result based on @val in interval [0, @ep_ro).
193 */
194static inline u32 reciprocal_scale(u32 val, u32 ep_ro)
195{
196 return (u32)(((u64) val * ep_ro) >> 32);
197}
198
199u64 int_pow(u64 base, unsigned int exp);
200unsigned long int_sqrt(unsigned long);
201
202#if BITS_PER_LONG < 64
203u32 int_sqrt64(u64 x);
204#else
205static inline u32 int_sqrt64(u64 x)
206{
207 return (u32)int_sqrt(x);
208}
209#endif
210
211#endif /* _LINUX_MATH_H */