include/linux/fixp-arith.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 #ifndef _FIXP_ARITH_H
   3 #define _FIXP_ARITH_H
   4
   5 #include <linux/bug.h>
   6 #include <linux/math64.h>
   7
   8 /*
   9  * Simplistic fixed-point arithmetics.
  10  * Hmm, I'm probably duplicating some code :(
  11  *
  12  * Copyright (c) 2002 Johann Deneux
  13  */
  14
  15 /*
  16  *
  17  * Should you need to contact me, the author, you can do so by
  18  * e-mail - mail your message to <johann.deneux@gmail.com>
  19  */
  20
  21 #include <linux/types.h>
  22
  23 static const s32 sin_table[] = {
  24         0x00000000, 0x023be165, 0x04779632, 0x06b2f1d2, 0x08edc7b6, 0x0b27eb5c,
  25         0x0d61304d, 0x0f996a26, 0x11d06c96, 0x14060b67, 0x163a1a7d, 0x186c6ddd,
  26         0x1a9cd9ac, 0x1ccb3236, 0x1ef74bf2, 0x2120fb82, 0x234815ba, 0x256c6f9e,
  27         0x278dde6e, 0x29ac379f, 0x2bc750e8, 0x2ddf003f, 0x2ff31bdd, 0x32037a44,
  28         0x340ff241, 0x36185aee, 0x381c8bb5, 0x3a1c5c56, 0x3c17a4e7, 0x3e0e3ddb,
  29         0x3fffffff, 0x41ecc483, 0x43d464fa, 0x45b6bb5d, 0x4793a20f, 0x496af3e1,
  30         0x4b3c8c11, 0x4d084650, 0x4ecdfec6, 0x508d9210, 0x5246dd48, 0x53f9be04,
  31         0x55a6125a, 0x574bb8e5, 0x58ea90c2, 0x5a827999, 0x5c135399, 0x5d9cff82,
  32         0x5f1f5ea0, 0x609a52d1, 0x620dbe8a, 0x637984d3, 0x64dd894f, 0x6639b039,
  33         0x678dde6d, 0x68d9f963, 0x6a1de735, 0x6b598ea1, 0x6c8cd70a, 0x6db7a879,
  34         0x6ed9eba0, 0x6ff389de, 0x71046d3c, 0x720c8074, 0x730baeec, 0x7401e4bf,
  35         0x74ef0ebb, 0x75d31a5f, 0x76adf5e5, 0x777f903b, 0x7847d908, 0x7906c0af,
  36         0x79bc384c, 0x7a6831b8, 0x7b0a9f8c, 0x7ba3751c, 0x7c32a67c, 0x7cb82884,
  37         0x7d33f0c8, 0x7da5f5a3, 0x7e0e2e31, 0x7e6c924f, 0x7ec11aa3, 0x7f0bc095,
  38         0x7f4c7e52, 0x7f834ecf, 0x7fb02dc4, 0x7fd317b3, 0x7fec09e1, 0x7ffb025e,
  39         0x7fffffff
  40 };
  41
  42 /**
  43  * __fixp_sin32() returns the sin of an angle in degrees
  44  *
  45  * @degrees: angle, in degrees, from 0 to 360.
  46  *
  47  * The returned value ranges from -0x7fffffff to +0x7fffffff.
  48  */
  49 static inline s32 __fixp_sin32(int degrees)
  50 {
  51         s32 ret;
  52         bool negative = false;
  53
  54         if (degrees > 180) {
  55                 negative = true;
  56                 degrees -= 180;
  57         }
  58         if (degrees > 90)
  59                 degrees = 180 - degrees;
  60
  61         ret = sin_table[degrees];
  62
  63         return negative ? -ret : ret;
  64 }
  65
  66 /**
  67  * fixp_sin32() returns the sin of an angle in degrees
  68  *
  69  * @degrees: angle, in degrees. The angle can be positive or negative
  70  *
  71  * The returned value ranges from -0x7fffffff to +0x7fffffff.
  72  */
  73 static inline s32 fixp_sin32(int degrees)
  74 {
  75         degrees = (degrees % 360 + 360) % 360;
  76
  77         return __fixp_sin32(degrees);
  78 }
  79
  80 /* cos(x) = sin(x + 90 degrees) */
  81 #define fixp_cos32(v) fixp_sin32((v) + 90)
  82
  83 /*
  84  * 16 bits variants
  85  *
  86  * The returned value ranges from -0x7fff to 0x7fff
  87  */
  88
  89 #define fixp_sin16(v) (fixp_sin32(v) >> 16)
  90 #define fixp_cos16(v) (fixp_cos32(v) >> 16)
  91
  92 /**
  93  * fixp_sin32_rad() - calculates the sin of an angle in radians
  94  *
  95  * @radians: angle, in radians
  96  * @twopi: value to be used for 2*pi
  97  *
  98  * Provides a variant for the cases where just 360
  99  * values is not enough. This function uses linear
 100  * interpolation to a wider range of values given by
 101  * twopi var.
 102  *
 103  * Experimental tests gave a maximum difference of
 104  * 0.000038 between the value calculated by sin() and
 105  * the one produced by this function, when twopi is
 106  * equal to 360000. That seems to be enough precision
 107  * for practical purposes.
 108  *
 109  * Please notice that two high numbers for twopi could cause
 110  * overflows, so the routine will not allow values of twopi
 111  * bigger than 1^18.
 112  */
 113 static inline s32 fixp_sin32_rad(u32 radians, u32 twopi)
 114 {
 115         int degrees;
 116         s32 v1, v2, dx, dy;
 117         s64 tmp;
 118
 119         /*
 120          * Avoid too large values for twopi, as we don't want overflows.
 121          */
 122         BUG_ON(twopi > 1 << 18);
 123
 124         degrees = (radians * 360) / twopi;
 125         tmp = radians - (degrees * twopi) / 360;
 126
 127         degrees = (degrees % 360 + 360) % 360;
 128         v1 = __fixp_sin32(degrees);
 129
 130         v2 = fixp_sin32(degrees + 1);
 131
 132         dx = twopi / 360;
 133         dy = v2 - v1;
 134
 135         tmp *= dy;
 136
 137         return v1 +  div_s64(tmp, dx);
 138 }
 139
 140 /* cos(x) = sin(x + pi/2 radians) */
 141
 142 #define fixp_cos32_rad(rad, twopi)      \
 143         fixp_sin32_rad(rad + twopi / 4, twopi)
 144
 145 /**
 146  * fixp_linear_interpolate() - interpolates a value from two known points
 147  *
 148  * @x0: x value of point 0
 149  * @y0: y value of point 0
 150  * @x1: x value of point 1
 151  * @y1: y value of point 1
 152  * @x: the linear interpolant
 153  */
 154 static inline int fixp_linear_interpolate(int x0, int y0, int x1, int y1, int x)
 155 {
 156         if (y0 == y1 || x == x0)
 157                 return y0;
 158         if (x1 == x0 || x == x1)
 159                 return y1;
 160
 161         return y0 + ((y1 - y0) * (x - x0) / (x1 - x0));
 162 }
 163
 164 #endif