View Javadoc

1   ////////////////////////////////////////////////////////////////////////////////
2   //CabaWeb
3   //Copyright (C) 2004  Thomas Vogt <Thomas.Vogt@TVC-Software.com>
4   //
5   //This library is free software; you can redistribute it and/or
6   //modify it under the terms of the GNU Lesser General Public
7   //License as published by the Free Software Foundation; either
8   //version 2.1 of the License, or (at your option) any later version.
9   //
10  //This library is distributed in the hope that it will be useful,
11  //but WITHOUT ANY WARRANTY; without even the implied warranty of
12  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  //Lesser General Public License for more details.
14  //
15  //You should have received a copy of the GNU Lesser General Public
16  //License along with this library; if not, write to the Free Software
17  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ////////////////////////////////////////////////////////////////////////////////
19  
20  package org.fhw.cabaweb.math;
21  
22  import java.math.BigDecimal;
23  
24  /***
25   * Klasse um verschiedene allgemeine mathematische Funktionen zusammenzufassen
26   *
27   * @author	<a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
28   * @version	Version 1.0 10.03-07.04.2004
29   */
30  public class Common
31  {
32      /***
33       * Standardkonstruktor der nicht zug&auml;nglich sein soll, da dies eine Utility Klasse ist
34       */
35      protected Common()
36      {
37          throw new UnsupportedOperationException(); // Aufrufe aus eventuellen SubKlassen verhindern
38      }
39  
40      /***
41       * Interface mit den ben&ouml;tigten Konstanten
42       */
43      interface Konstanten
44      {
45          /***
46           * Anzahl der Stellen auf die gerundet wird -> 0
47           */
48          public static final int KEINESTELLEN = 0;
49          /***
50           * Anzahl der Stellen auf die gerundet wird -> 1
51           */
52          public static final int EINESTELLE = 1;
53          /***
54           * Anzahl der Stellen auf die gerundet wird -> 2
55           */
56          public static final int ZWEISTELLEN = 2;
57          /***
58           * Anzahl der Stellen auf die gerundet wird -> 3
59           */
60          public static final int DREISTELLEN = 3;
61          /***
62           * Anzahl der Stellen auf die gerundet wird -> 10
63           */
64          public static final int ZEHNSTELLEN = 10;
65          /***
66           * Konstante für eine double Null Komma Null -> 0.0
67           */
68          public static final double ZERO = 0.0;
69          /***
70           * Konstante für eine double Ein Tausend Komma Null -> 1000.0
71           */
72          public static final double EINTAUSEND = 1000.0;
73      }
74  
75      /***
76       * Gibt den geliefertern double Wert auf 1 Nachkommastelle gerundet zur&uuml;ck
77       *
78       * @param   wert    Wert der gerundet werden soll
79       * @return  Gerundeter Wert
80       */
81      public static final double aufEineNachkommastelleRunden(final double wert)
82      {
83          BigDecimal rundung = new BigDecimal(wert);
84          rundung = rundung.setScale(Konstanten.EINESTELLE, java.math.BigDecimal.ROUND_HALF_UP);
85          double rueckgabewert = rundung.doubleValue();
86  
87          return rueckgabewert;
88      }
89  
90      /***
91       * Gibt den geliefertern double Wert auf 2 Nachkommastellen gerundet zur&uuml;ck
92       *
93       * @param   wert    Wert der gerundet werden soll
94       * @return  Gerundeter Wert
95       */
96      public static final double aufZweiNachkommastellenRunden(final double wert)
97      {
98          BigDecimal rundung = new BigDecimal(wert);
99          rundung = rundung.setScale(Konstanten.ZWEISTELLEN, java.math.BigDecimal.ROUND_HALF_UP);
100         double rueckgabewert = rundung.doubleValue();
101 
102         return rueckgabewert;
103     }
104 
105     /***
106      * Gibt den geliefertern double Wert auf 3 Nachkommastellen gerundet zur&uuml;ck
107      *
108      * @param   wert    Wert der gerundet werden soll
109      * @return  Gerundeter Wert
110      */
111     public static final double aufDreiNachkommastellenRunden(final double wert)
112     {
113         BigDecimal rundung = new BigDecimal(wert);
114         rundung = rundung.setScale(Konstanten.DREISTELLEN, java.math.BigDecimal.ROUND_HALF_UP);
115         double rueckgabewert = rundung.doubleValue();
116 
117         return rueckgabewert;
118     }
119 
120     /***
121      * Gibt den geliefertern double Wert auf 10 Nachkommastellen gerundet zur&uuml;ck
122      *
123      * @param   wert    Wert der gerundet werden soll
124      * @return  Gerundeter Wert
125      */
126     public static final double aufZehnNachkommastellenRunden(final double wert)
127     {
128         BigDecimal rundung = new BigDecimal(wert);
129         rundung = rundung.setScale(Konstanten.ZEHNSTELLEN, java.math.BigDecimal.ROUND_HALF_UP);
130         double rueckgabewert = rundung.doubleValue();
131 
132         return rueckgabewert;
133     }
134 
135     /***
136      * Gibt den geliefertern double Wert als gerundeten Integer (int) zur&uuml;ck
137      *
138      * @param   wert    Wert der gerundet und umgewandelt werden soll
139      * @return  Gerundeter und umgewandelter Wert
140      */
141     public static final int aufIntegerRunden(final double wert)
142     {
143         BigDecimal rundung = new BigDecimal(wert);
144         rundung = rundung.setScale(Konstanten.KEINESTELLEN, java.math.BigDecimal.ROUND_HALF_UP);
145         int rueckgabewert = rundung.intValue();
146 
147         return rueckgabewert;
148     }
149 
150     /***
151      * Gibt den geliefertern double Wert als aufgerundeten Integer (int) / 1000 zur&uuml;ck
152      *
153      * @param   wert    Wert der aufgerundet und umgewandelt werden soll
154      * @return  Gerundeter und umgewandelter Wert
155      */
156     public static final int aufIntegerDurchEinTausendAufrunden(final double wert)
157     {
158         BigDecimal rundung = new BigDecimal(wert / Konstanten.EINTAUSEND);
159         rundung = rundung.setScale(Konstanten.KEINESTELLEN, java.math.BigDecimal.ROUND_HALF_UP);
160         int rueckgabewert = rundung.intValue();
161 
162         return rueckgabewert;
163     }
164 
165     /***
166      * Gibt das Ergebnis der Division von Z&auml;hler und Nenner zur&uuml;ck.
167      * Im Falle das der Nenner = 0 ist wird je nach Art des Z&auml;hlers
168      * der Wert für positive oder negative Unendlichkeit zur&uuml;ckgegeben.
169      *
170      * @param	zaehler	Wert der geteilt werden soll
171      * @param	nenner	Wert durch den geteilt werden soll
172      * @return	Gerundeter Wert
173      */
174     public static final double divide(final double zaehler, final double nenner)
175     {
176         double ergebnis = Konstanten.ZERO;
177 
178         if (nenner == Konstanten.ZERO)
179         {
180             if (zaehler == Konstanten.ZERO)
181             {
182                 ergebnis = Konstanten.ZERO;
183             }
184             else if (zaehler < Konstanten.ZERO)
185             {
186                 ergebnis = Double.NEGATIVE_INFINITY;
187             }
188             else if (zaehler > Konstanten.ZERO)
189             {
190                 ergebnis = Double.POSITIVE_INFINITY;
191             }
192         }
193         else
194         {
195             // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse
196             // Rundung auf 10 Nachkommastellen
197             ergebnis = aufZehnNachkommastellenRunden(zaehler / nenner);
198         }
199 
200         double rueckgabewert = ergebnis;
201 
202         return rueckgabewert;
203     }
204 
205 }