1 /* Fixed.java -- Utility methods for fixed point arithmetics
2    Copyright (C) 2006 Free Software Foundation, Inc.
3 
4 This file is part of GNU Classpath.
5 
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10 
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 General Public License for more details.
15 
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING.  If not, write to the
18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20 
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library.  Thus, the terms and
23 conditions of the GNU General Public License cover the whole
24 combination.
25 
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module.  An independent module is a module which is not derived from
33 or based on this library.  If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so.  If you do not wish to do so, delete this
36 exception statement from your version. */
37 
38 
39 package gnu.java.math;
40 
41 /**
42  * Utility methods for fixed point arithmetics.
43  */
44 public final class Fixed
45 {
46 
47   /**
48    * Private constructor to avoid instantiation.
49    */
Fixed()50   private Fixed()
51   {
52     // Forbidden constructor.
53   }
54 
55   /**
56    * Divides two fixed point values with <code>n</code> digits.
57    *
58    * @param n the number of digits
59    * @param a the first operand as fixed point value
60    * @param b the second operand as fixed point value
61    *
62    * @return <code>a / b</code> as fixed point value
63    */
div(int n, int a, int b)64   public static int div(int n, int a, int b)
65   {
66     return (int) ((((long) a) << n) / b);
67   }
68 
69   /**
70    * Multiplies two fixed point values with <code>n</code> digits.
71    *
72    * @param n the number of digits
73    * @param a the first operand as fixed point value
74    * @param b the second operand as fixed point value
75    *
76    * @return <code>a * b</code> as fixed point value
77    */
mul(int n, int a, int b)78   public static int mul(int n, int a, int b)
79   {
80     return (int) ((((long) a) * b) >> n);
81   }
82 
83   /**
84    * Returns the ceiling value of a fixed point value <code>a</code> with
85    * the <code>n</code> digits.
86    *
87    * @param n the number of digits
88    * @param a the fixed point value
89    *
90    * @return <code>ceil(a)</code> as fixed point value
91    */
ceil(int n, int a)92   public static int ceil(int n, int a)
93   {
94     return (a + (1 << n - 1)) & -(1 << n);
95   }
96 
97   /**
98    * Returns the floor value of a fixed point value <code>a</code> with
99    * <code>n</code> digits.
100    *
101    * @param n the number of digits
102    * @param a the fixed point value
103    *
104    * @return <code>floor(a)</code> as fixed point value
105    */
floor(int n, int a)106   public static int floor(int n, int a)
107   {
108     return a & -(1 << n);
109   }
110 
111   /**
112    * Truncates the number so that only the digits after the point are left.
113    *
114    * @param n the number of digits
115    * @param a the fixed point value
116    *
117    * @return the truncated value
118    */
trunc(int n, int a)119   public static int trunc(int n, int a)
120   {
121     return a & (0xFFFFFFFF >>> 32 - n);
122   }
123 
124   /**
125    * Returns the round value of a fixed point value <code>a</code> with
126    * the <code>n</code> digits.
127    *
128    * @param n the number of digits
129    * @param a the fixed point value
130    *
131    * @return <code>round(a)</code> as fixed point value
132    */
round(int n, int a)133   public static int round(int n, int a)
134   {
135     return (a + (1 << (n - 1))) & -(1 << n);
136   }
137 
138   /**
139    * Returns the fixed point value <code>a</code> with <code>n</code> digits
140    * as float.
141    *
142    * @param n the number of digits
143    * @param a the fixed point value
144    *
145    * @return the float value of <code>a</code>
146    */
floatValue(int n, int a)147   public static float floatValue(int n, int a)
148   {
149     return ((float) a) / (1 << n);
150   }
151 
152   /**
153    * Returns the fixed point value <code>a</code> with <code>n</code> digits
154    * as double.
155    *
156    * @param n the number of digits
157    * @param a the fixed point value
158    *
159    * @return the double value of <code>a</code>
160    */
doubleValue(int n, int a)161   public static double doubleValue(int n, int a)
162   {
163     return ((double) a) / (1 << n);
164   }
165 
166   /**
167    * Returns the fixed point value that corresponds to the specified float
168    * value <code>a</code> with <code>n</code> digits.
169    *
170    * @param n the number of digits
171    * @param a the float value
172    *
173    * @return the fixed point value
174    */
fixedValue(int n, float a)175   public static int fixedValue(int n, float a)
176   {
177     return (int) (a * (1 << n));
178   }
179 
180   /**
181    * Returns the fixed point value that corresponds to the specified double
182    * value <code>a</code> with <code>n</code> digits.
183    *
184    * @param n the number of digits
185    * @param a the double value
186    *
187    * @return the fixed point value
188    */
fixedValue(int n, double a)189   public static int fixedValue(int n, double a)
190   {
191     return (int) (a * (1 << n));
192   }
193 
194   /**
195    * Returns the integer value of the specified fixed point value
196    * <code>a</code>. This simply cuts of the digits (== floor(a)).
197    *
198    * @param n the number of digits
199    * @param a the fixed point value
200    *
201    * @return the integer value
202    */
intValue(int n, int a)203   public static int intValue(int n, int a)
204   {
205     return a >> n;
206   }
207 
208   /**
209    * Returns a fixed point decimal as rounded integer value.
210    *
211    * @param n the number of digits
212    * @param a the fixed point number
213    *
214    * @return the fixed point decimal as rounded integer value
215    */
roundIntValue(int n, int a)216   public static int roundIntValue(int n, int a)
217   {
218     return (a + (1 << (n - 1))) >> n;
219   }
220 }
221