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-only
2/*
3 * Generic polynomial calculation using integer coefficients.
4 *
5 * Copyright (C) 2020 BAIKAL ELECTRONICS, JSC
6 *
7 * Authors:
8 * Maxim Kaurkin <maxim.kaurkin@baikalelectronics.ru>
9 * Serge Semin <Sergey.Semin@baikalelectronics.ru>
10 *
11 */
12
13#include <linux/export.h>
14#include <linux/math.h>
15#include <linux/module.h>
16#include <linux/polynomial.h>
17
18/*
19 * The following conversion is an example:
20 *
21 * The original translation formulae of the temperature (in degrees of Celsius)
22 * to PVT data and vice-versa are following:
23 *
24 * N = 1.8322e-8*(T^4) + 2.343e-5*(T^3) + 8.7018e-3*(T^2) + 3.9269*(T^1) + 1.7204e2
25 * T = -1.6743e-11*(N^4) + 8.1542e-8*(N^3) + -1.8201e-4*(N^2) + 3.1020e-1*(N^1) - 4.838e1
26 *
27 * where T = [-48.380, 147.438]C and N = [0, 1023].
28 *
29 * They must be accordingly altered to be suitable for the integer arithmetics.
30 * The technique is called 'factor redistribution', which just makes sure the
31 * multiplications and divisions are made so to have a result of the operations
32 * within the integer numbers limit. In addition we need to translate the
33 * formulae to accept millidegrees of Celsius. Here what they look like after
34 * the alterations:
35 *
36 * N = (18322e-20*(T^4) + 2343e-13*(T^3) + 87018e-9*(T^2) + 39269e-3*T + 17204e2) / 1e4
37 * T = -16743e-12*(D^4) + 81542e-9*(D^3) - 182010e-6*(D^2) + 310200e-3*D - 48380
38 *
39 * where T = [-48380, 147438] mC and N = [0, 1023].
40 *
41 * static const struct polynomial poly_temp_to_N = {
42 * .total_divider = 10000,
43 * .terms = {
44 * {4, 18322, 10000, 10000},
45 * {3, 2343, 10000, 10},
46 * {2, 87018, 10000, 10},
47 * {1, 39269, 1000, 1},
48 * {0, 1720400, 1, 1}
49 * }
50 * };
51 *
52 * static const struct polynomial poly_N_to_temp = {
53 * .total_divider = 1,
54 * .terms = {
55 * {4, -16743, 1000, 1},
56 * {3, 81542, 1000, 1},
57 * {2, -182010, 1000, 1},
58 * {1, 310200, 1000, 1},
59 * {0, -48380, 1, 1}
60 * }
61 * };
62 */
63
64/**
65 * polynomial_calc - calculate a polynomial using integer arithmetic
66 *
67 * @poly: pointer to the descriptor of the polynomial
68 * @data: input value of the polynomial
69 *
70 * Calculate the result of a polynomial using only integer arithmetic. For
71 * this to work without too much loss of precision the coefficients has to
72 * be altered. This is called factor redistribution.
73 *
74 * Return: the result of the polynomial calculation.
75 */
76long polynomial_calc(const struct polynomial *poly, long data)
77{
78 const struct polynomial_term *term = poly->terms;
79 long total_divider = poly->total_divider ?: 1;
80 long tmp, ret = 0;
81 int deg;
82
83 /*
84 * Here is the polynomial calculation function, which performs the
85 * redistributed terms calculations. It's pretty straightforward.
86 * We walk over each degree term up to the free one, and perform
87 * the redistributed multiplication of the term coefficient, its
88 * divider (as for the rationale fraction representation), data
89 * power and the rational fraction divider leftover. Then all of
90 * this is collected in a total sum variable, which value is
91 * normalized by the total divider before being returned.
92 */
93 do {
94 tmp = term->coef;
95 for (deg = 0; deg < term->deg; ++deg)
96 tmp = mult_frac(tmp, data, term->divider);
97 ret += tmp / term->divider_leftover;
98 } while ((term++)->deg);
99
100 return ret / total_divider;
101}
102EXPORT_SYMBOL_GPL(polynomial_calc);
103
104MODULE_DESCRIPTION("Generic polynomial calculations");
105MODULE_LICENSE("GPL");