linear_range.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022, Nordic Semiconductor ASA
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef INCLUDE_ZEPHYR_SYS_LINEAR_RANGE_H_
#define INCLUDE_ZEPHYR_SYS_LINEAR_RANGE_H_
 
#include <errno.h>
#include <stdint.h>
#include <stdlib.h>
 
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif


struct linear_range {
        int32_t min;
        uint32_t step;
        uint16_t min_idx;
        uint16_t max_idx;
};

#define LINEAR_RANGE_INIT(_min, _step, _min_idx, _max_idx)                     \
        {                                                                      \
                .min = (_min),                                                 \
                .step = (_step),                                               \
                .min_idx = (_min_idx),                                         \
                .max_idx = (_max_idx),                                         \
        }

static inline uint32_t linear_range_values_count(const struct linear_range *r)
{
        return r->max_idx - r->min_idx + 1U;
}

static inline uint32_t linear_range_group_values_count(
        const struct linear_range *r, size_t r_cnt)
{
        uint32_t values = 0U;
 
        for (size_t i = 0U; i < r_cnt; i++) {
                values += linear_range_values_count(&r[i]);
        }
 
        return values;
}

static inline int32_t linear_range_get_max_value(const struct linear_range *r)
{
        return r->min + (int32_t)(r->step * (r->max_idx - r->min_idx));
}

static inline int linear_range_get_value(const struct linear_range *r,
                                         uint16_t idx, int32_t *val)
{
        if ((idx < r->min_idx) || (idx > r->max_idx)) {
                return -EINVAL;
        }
 
        *val = r->min + (int32_t)(r->step * (idx - r->min_idx));
 
        return 0;
}

static inline int linear_range_group_get_value(const struct linear_range *r,
                                               size_t r_cnt, uint16_t idx,
                                               int32_t *val)
{
        int ret = -EINVAL;
 
        for (size_t i = 0U; (ret != 0) && (i < r_cnt); i++) {
                ret = linear_range_get_value(&r[i], idx, val);
        }
 
        return ret;
}

static inline int linear_range_get_index(const struct linear_range *r,
                                         int32_t val, uint16_t *idx)
{
        if (val < r->min) {
                *idx = r->min_idx;
                return -ERANGE;
        }
 
        if (val > linear_range_get_max_value(r)) {
                *idx = r->max_idx;
                return -ERANGE;
        }
 
        if (r->step == 0U) {
                *idx = r->min_idx;
        } else {
                *idx = r->min_idx + DIV_ROUND_UP((uint32_t)(val - r->min),
                                                 r->step);
        }
 
        return 0;
}

static inline int linear_range_group_get_index(const struct linear_range *r,
                                               size_t r_cnt, int32_t val,
                                               uint16_t *idx)
{
        for (size_t i = 0U; i < r_cnt; i++) {
                if ((val > linear_range_get_max_value(&r[i])) &&
                    (i < (r_cnt - 1U))) {
                        continue;
                }
 
                return linear_range_get_index(&r[i], val, idx);
        }
 
        return -EINVAL;
}

static inline int linear_range_get_win_index(const struct linear_range *r,
                                             int32_t val_min, int32_t val_max,
                                             uint16_t *idx)
{
        int32_t r_max = linear_range_get_max_value(r);
 
        if ((val_max < r->min) || (val_min > r_max)) {
                return -EINVAL;
        }
 
        if (val_min < r->min) {
                *idx = r->min_idx;
                return -ERANGE;
        }
 
        if (val_max > r_max) {
                *idx = r->max_idx;
                return -ERANGE;
        }
 
        if (r->step == 0U) {
                *idx = r->min_idx;
                return 0;
        }
 
        *idx = r->min_idx + DIV_ROUND_UP((uint32_t)(val_min - r->min), r->step);
        if ((r->min + r->step * (*idx - r->min_idx)) > val_max) {
                return -EINVAL;
        }
 
        return 0;
}

static inline int linear_range_group_get_win_index(const struct linear_range *r,
                                                   size_t r_cnt,
                                                   int32_t val_min,
                                                   int32_t val_max,
                                                   uint16_t *idx)
{
        for (size_t i = 0U; i < r_cnt; i++) {
                if (val_min > linear_range_get_max_value(&r[i])) {
                        continue;
                }
 
                return linear_range_get_win_index(&r[i], val_min, val_max, idx);
        }
 
        return -EINVAL;
}

 
#ifdef __cplusplus
}
#endif
 
#endif /* INCLUDE_ZEPHYR_SYS_LINEAR_RANGE_H_ */