# lv_math.h (/api/misc/lv_math_h)
Functions [#functions]
lv_rand_set_seed [#lv_rand_set_seed]
Set the seed of the pseudo random number generator
```c title=" " lineNumbers=1
void lv_rand_set_seed(uint32_t seed)
```
Parameters
| Name | Type | Description |
| ------ | --------------------------- | ------------------------------------------- |
| `seed` | | a number to initialize the random generator |
lv_trigo_sin [#lv_trigo_sin]
Return with sinus of an angle
```c title=" " lineNumbers=1
int32_t lv_trigo_sin(int16_t angle)
```
Parameters
| Name | Type |
| ------- | -------------------------- |
| `angle` | |
**Returns:** — sinus of 'angle'. sin(-90) = -32767, sin(90) = 32767
lv_trigo_cos [#lv_trigo_cos]
```c title=" " lineNumbers=1
int32_t lv_trigo_cos(int16_t angle)
```
Parameters
| Name | Type |
| ------- | -------------------------- |
| `angle` | |
lv_cubic_bezier [#lv_cubic_bezier]
Calculate the y value of cubic-bezier(x1, y1, x2, y2) function as specified x.
```c title=" " lineNumbers=1
int32_t lv_cubic_bezier(int32_t x, int32_t x1, int32_t y1, int32_t x2, int32_t y2)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------- | ----------------------------------------------------------- |
| `x` | | time in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `x1` | | x of control point 1 in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `y1` | | y of control point 1 in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `x2` | | x of control point 2 in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `y2` | | y of control point 2 in range of \[0..LV\_BEZIER\_VAL\_MAX] |
**Returns:** — the value calculated
lv_bezier3 [#lv_bezier3]
Calculate a value of a Cubic Bezier function.
```c title=" " lineNumbers=1
int32_t lv_bezier3(int32_t t, int32_t u0, uint32_t u1, int32_t u2, int32_t u3)
```
Parameters
| Name | Type | Description |
| ---- | --------------------------- | ------------------------------------------------------------- |
| `t` | | time in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `u0` | | must be 0 |
| `u1` | | control value 1 values in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `u2` | | control value 2 in range of \[0..LV\_BEZIER\_VAL\_MAX] |
| `u3` | | must be LV\_BEZIER\_VAL\_MAX |
**Returns:** — the value calculated from the given parameters in range of \[0..LV\_BEZIER\_VAL\_MAX]
lv_atan2 [#lv_atan2]
Calculate the atan2 of a vector.
```c title=" " lineNumbers=1
uint16_t lv_atan2(int x, int y)
```
Parameters
| Name | Type |
| ---- | ----- |
| `x` | `int` |
| `y` | `int` |
**Returns:** — the angle in degree calculated from the given parameters in range of \[0..360]
lv_sqrt [#lv_sqrt]
Get the square root of a number
```c title=" " lineNumbers=1
void lv_sqrt(uint32_t x, lv_sqrt_res_t *q, uint32_t mask)
```
Parameters
| Name | Type | Description |
| ------ | ---------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `x` | | integer which square root should be calculated |
| `q` | | store the result here. q->i: integer part, q->f: fractional part in 1/256 unit |
| `mask` | | optional to skip some iterations if the magnitude of the root is known. Set to 0x8000 by default. If root \< 16: mask = 0x80 If root \< 256: mask = 0x800 Else: mask = 0x8000 |
lv_sqrt32 [#lv_sqrt32]
Alternative (fast, approximate) implementation for getting the square root of an integer.
```c title=" " lineNumbers=1
int32_t lv_sqrt32(uint32_t x)
```
Parameters
| Name | Type | Description |
| ---- | --------------------------- | ---------------------------------------------- |
| `x` | | integer which square root should be calculated |
lv_sqr [#lv_sqr]
Calculate the square of an integer (input range is 0..32767).
```c title=" " lineNumbers=1
static int32_t lv_sqr(int32_t x)
```
Parameters
| Name | Type | Description |
| ---- | -------------------------- | ----------- |
| `x` | | input |
**Returns:** — square
lv_pow [#lv_pow]
Calculate the integer exponents.
```c title=" " lineNumbers=1
int64_t lv_pow(int64_t base, int8_t exp)
```
Parameters
| Name | Type |
| ------ | -------------------------- |
| `base` | |
| `exp` | |
**Returns:** — base raised to the power exponent
lv_map [#lv_map]
Get the mapped of a number given an input and output range
```c title=" " lineNumbers=1
int32_t lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min_out, int32_t max_out)
```
Parameters
| Name | Type | Description |
| --------- | -------------------------- | ----------------------------------------------- |
| `x` | | integer which mapped value should be calculated |
| `min_in` | | min input range |
| `max_in` | | max input range |
| `min_out` | | max output range |
| `max_out` | | max output range |
**Returns:** — the mapped number
lv_rand [#lv_rand]
Get a pseudo random number in the given range
```c title=" " lineNumbers=1
uint32_t lv_rand(uint32_t min, uint32_t max)
```
Parameters
| Name | Type | Description |
| ----- | --------------------------- | ----------------- |
| `min` | | the minimum value |
| `max` | | the maximum value |
**Returns:** — return the random number. min \<= return\_value \<= max
Structs [#structs]
lv_sqrt_res_t [#lv_sqrt_res_t]
| Member | Type | Description |
| ------ | --------------------------- | ----------- |
| `i` | | |
| `f` | | |
* `lv_sqrt` — param `q`
Macros [#macros]
LV_TRIGO_SIN_MAX [#lv_trigo_sin_max]
```c title=" " lineNumbers=1
#define LV_TRIGO_SIN_MAX 32768
```
LV_TRIGO_SHIFT [#lv_trigo_shift]
```c title=" " lineNumbers=1
#define LV_TRIGO_SHIFT 15
```
\> > LV\_TRIGO\_SHIFT to normalize
LV_BEZIER_VAL_SHIFT [#lv_bezier_val_shift]
```c title=" " lineNumbers=1
#define LV_BEZIER_VAL_SHIFT 10
```
log2(LV\_BEZIER\_VAL\_MAX): used to normalize up scaled values
LV_BEZIER_VAL_MAX [#lv_bezier_val_max]
```c title=" " lineNumbers=1
#define LV_BEZIER_VAL_MAX (1L << LV_BEZIER_VAL_SHIFT)
```
Max time in Bezier functions (not \[0..1] to use integers)
LV_BEZIER_VAL_FLOAT [#lv_bezier_val_float]
```c title=" " lineNumbers=1
#define LV_BEZIER_VAL_FLOAT(f) \
((int32_t)((f) * LV_BEZIER_VAL_MAX))
```
Convert const float number cubic-bezier values to fix-point value
LV_ALIGN_UP [#lv_align_up]
```c title=" " lineNumbers=1
#define LV_ALIGN_UP(x, align) \
(((x) + ((align) - 1)) & ~((align) - 1))
```
Align up value x to align, align must be a power of two
LV_ROUND_UP [#lv_round_up]
```c title=" " lineNumbers=1
#define LV_ROUND_UP(x, round) \
((((x) + ((round) - 1)) / (round)) * (round))
```
Round up value x to round, round can be any integer number
LV_MIN [#lv_min]
```c title=" " lineNumbers=1
#define LV_MIN(a, b) \
((a) < (b) ? (a) : (b))
```
LV_MIN3 [#lv_min3]
```c title=" " lineNumbers=1
#define LV_MIN3(a, b, c) \
(LV_MIN(LV_MIN(a,b), c))
```
LV_MIN4 [#lv_min4]
```c title=" " lineNumbers=1
#define LV_MIN4(a, b, c, d) \
(LV_MIN(LV_MIN(a,b), LV_MIN(c,d)))
```
LV_MAX [#lv_max]
```c title=" " lineNumbers=1
#define LV_MAX(a, b) \
((a) > (b) ? (a) : (b))
```
LV_MAX3 [#lv_max3]
```c title=" " lineNumbers=1
#define LV_MAX3(a, b, c) \
(LV_MAX(LV_MAX(a,b), c))
```
LV_MAX4 [#lv_max4]
```c title=" " lineNumbers=1
#define LV_MAX4(a, b, c, d) \
(LV_MAX(LV_MAX(a,b), LV_MAX(c,d)))
```
LV_CLAMP [#lv_clamp]
```c title=" " lineNumbers=1
#define LV_CLAMP(min, val, max) \
(LV_MAX(min, (LV_MIN(val, max))))
```
LV_ABS [#lv_abs]
```c title=" " lineNumbers=1
#define LV_ABS(x) \
((x) > 0 ? (x) : (-(x)))
```
LV_UDIV255 [#lv_udiv255]
```c title=" " lineNumbers=1
#define LV_UDIV255(x) \
(((x) * 0x8081U) >> 0x17)
```
LV_IS_SIGNED [#lv_is_signed]
```c title=" " lineNumbers=1
#define LV_IS_SIGNED(t) \
(((t)(-1)) < ((t)0))
```
LV_UMAX_OF [#lv_umax_of]
```c title=" " lineNumbers=1
#define LV_UMAX_OF(t) \
(((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0xFULL << ((sizeof(t) * 8ULL) - 4ULL)))
```
LV_SMAX_OF [#lv_smax_of]
```c title=" " lineNumbers=1
#define LV_SMAX_OF(t) \
(((0x1ULL << ((sizeof(t) * 8ULL) - 1ULL)) - 1ULL) | (0x7ULL << ((sizeof(t) * 8ULL) - 4ULL)))
```
LV_MAX_OF [#lv_max_of]
```c title=" " lineNumbers=1
#define LV_MAX_OF(t) \
((unsigned long)(LV_IS_SIGNED(t) ? LV_SMAX_OF(t) : LV_UMAX_OF(t)))
```
Dependencies [#dependencies]