Vertrieb xref

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.util.ArrayList;
23  
24  import org.fhw.cabaweb.data.dataobjects.Marketingeffekt;
25  import org.fhw.cabaweb.data.dataobjects.Marktforschung;
26  import org.fhw.cabaweb.data.dataobjects.PreisAbsatz;
27  import org.fhw.cabaweb.data.dataobjects.GruppeWert;
28  
29  /***
30   * Klasse mit den Berechnungsfunktionen f&uuml;r den Vertrieb
31   *
32   * @author	<a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
33   * @version	Version 1.0 05-10.03.2004
34   */
35  public class Vertrieb
36  {
37      /***
38       * Standardkonstruktor der nicht zug&auml;nglich sein soll, da dies eine Utility Klasse ist
39       */
40      protected Vertrieb()
41      {
42          throw new UnsupportedOperationException(); // Aufrufe aus eventuellen SubKlassen verhindern
43      }
44  
45      /***
46       * Interface mit den ben&ouml;tigten Konstanten
47       */
48      interface Konstanten
49      {
50          /***
51           * Zahl die Hundert Prozent repr&auml;sentiert (100.0)
52           */
53          public static final double HUNDRED_PERCENT = 100.0;
54      }
55  
56      /***
57       * Liefert den aktuellen Inflationsindex zur&uuml;ck
58       * Tabelle 20 Zeile 11a
59       *
60       * @param	inflationsIndex	Alter Inflationsindex
61       * @param	inflationsRate	Inflationsrate (Prozentwert - Format 10.00 f&uuml;r 10 Prozent)
62       * @return	(Alter Inflationsindex * ((Inflationsrate / 100) + 1.00))
63       */
64      public static final double inflationsIndex(final double inflationsIndex, final double inflationsRate)
65      {
66          double ergebnis = (inflationsIndex * ((inflationsRate / Konstanten.HUNDRED_PERCENT) + 1.00));
67          // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
68          double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
69  
70          return rueckgabewert;
71      }
72  
73      /***
74       * Liefert den aktuellen Lohnerh&ouml;hungsindex zur&uuml;ck
75       *
76       * @param	lohnerhoehungsIndex	Alter Lohnerh&ouml;hungsindex
77       * @param	lohnerhoehung	Aktuelle Lohnerh&ouml;hung (Prozentwert - Format 10.00 f&uuml;r 10 Prozent)
78       * @return	(Alter Lohnerh&ouml;hungsindex * ((Lohnerh&ouml;hung/100.0) + 1.00))
79       */
80      public static final double lohnerhoehungsIndex(final double lohnerhoehungsIndex, final double lohnerhoehung)
81      {
82          double ergebnis = (lohnerhoehungsIndex * ((lohnerhoehung / Konstanten.HUNDRED_PERCENT) + 1.00));
83          // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
84          double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
85  
86          return rueckgabewert;
87      }
88  
89      /***
90       * Liefert den realen (inflationsbereinigten) Preis zur&uuml;ck
91       * Tabelle 20 Zeile 212
92       *
93       * @param	nominellerPreis	nomineller Verkaufspreis
94       * @param	inflationsIndex	Inflationsindex
95       * @return	(nomineller Preis / inflationsIndex)
96       */
97      public static final double realerPreis(final double nominellerPreis, final double inflationsIndex)
98      {
99          double ergebnis = (nominellerPreis / inflationsIndex);
100         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
101         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
102 
103         return rueckgabewert;
104     }
105 
106     /***
107      * Liefert den wirksamen Preis zur&uuml;ck
108      * Tabelle 20 Zeile 213
109      *
110      * @param	realerPreisAktuell	Realer Preis im aktuellen Quartal
111      * @param	realerPreisVorquartal	Realer Preis im vorhergehenden Quartal
112      * @param	praeferenzEffekt	Der Pr&auml;ferenzeffekt (Vorzug gegen&uuml;ber einem anderen Produkt)
113      * @param	marketingEffekt	Der Marketingeffekt
114      * @return	Der neue wirksame Preis
115      */
116     public static final double wirksamerPreis(final double realerPreisAktuell, final double realerPreisVorquartal, final double praeferenzEffekt, final double marketingEffekt)
117     {
118         double nenner = (1.0 + marketingEffekt) * (1.0 + praeferenzEffekt);
119         double quadrat = (realerPreisAktuell - realerPreisVorquartal) * (realerPreisAktuell - realerPreisVorquartal);
120         double ergebnis = ((realerPreisAktuell / nenner) + quadrat);
121         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
122         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
123 
124         return rueckgabewert;
125     }
126 
127     /***
128      * Liefert den wirksamen Preis gem&auml;ß Preis Absatz Funktion (PAF) zur&uuml;ck
129      *
130      * @param	absatz	Der Absatz an Produkten
131      * @param	preisAbsatzTabelle	Arrayliste mit den Voreinstellungswerten der Preis Abstatz Funktion (PAF) in n Elementen von preisAbsatz Objekten verpackt.
132      * @return	Der wirksame Preis gem&auml;ß Preis Absatz Funktion (PAF)
133      */
134     public static final double pafWirksamerPreis(final double absatz, final ArrayList preisAbsatzTabelle)
135     {
136         double absatzDifferenz = 0.0;
137         double preisIntervall = 0.0;
138         double absatzIntervall = 0.0;
139         double ergebnis = 0.0;
140 
141         int groessePreisAbsatzTabelle = preisAbsatzTabelle.size();
142 
143         if (absatz > ((PreisAbsatz) preisAbsatzTabelle.get(0)).getAbsatz())
144         {
145             ergebnis = ((PreisAbsatz) preisAbsatzTabelle.get(0)).getPreis();
146         }
147         else if (absatz <= ((PreisAbsatz) preisAbsatzTabelle.get((groessePreisAbsatzTabelle - 1))).getAbsatz())
148         {
149             ergebnis = ((PreisAbsatz) preisAbsatzTabelle.get(groessePreisAbsatzTabelle - 1)).getPreis();
150         }
151 
152         // suche das entsprechende Intervall
153         for (int i = 0; i < groessePreisAbsatzTabelle - 1; i++)
154         {
155             if ((((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getAbsatz() < absatz) && (absatz <= ((PreisAbsatz) preisAbsatzTabelle.get(i)).getAbsatz()))
156             {
157                 absatzDifferenz = (absatz - ((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getAbsatz());
158                 preisIntervall = (((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getPreis() - ((PreisAbsatz) preisAbsatzTabelle.get(i)).getPreis());
159                 absatzIntervall = (((PreisAbsatz) preisAbsatzTabelle.get(i)).getAbsatz() - ((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getAbsatz());
160                 // Interpolation
161                 ergebnis = ((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getPreis() - absatzDifferenz / absatzIntervall * preisIntervall;
162             }
163         }
164 
165         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
166         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
167 
168         return rueckgabewert;
169     }
170 
171     /***
172      * Liefert den realen Marketingwert zur&uuml;ck
173      *
174      * @param	nominellesMarketing	Der nominelle Marketingwert
175      * @param	inflationsIndex	Der aktuelle Inflationsindex
176      * @return	Der reale Marketingwert
177      */
178     public static final double realesMarketing(final double nominellesMarketing, final double inflationsIndex)
179     {
180         double ergebnis = (nominellesMarketing / inflationsIndex);
181 
182         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
183         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
184 
185         return rueckgabewert;
186     }
187 
188     /***
189      * Liefert den wirksamen Marketingwert zur&uuml;ck
190      *
191      * @param	nachhall	Wert f&uuml;r die Nachwirkung fr&uuml;her erbrachten Marketings in Prozenten < 1.00
192      * @param	realesMarketing	Der reale Marketingwert
193      * @param	wirksamesMarketingVorquartal	Der wirksame Marketingwert aus dem Vorquartal
194      * @return	Der wirksame Marketingwert
195      */
196     public static final double wirksamesMarketing(final double nachhall, final double realesMarketing, final double wirksamesMarketingVorquartal)
197     {
198         double ergebnis = ((realesMarketing * (1.0 - nachhall)) + (wirksamesMarketingVorquartal * nachhall));
199 
200         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
201         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
202 
203         return rueckgabewert;
204     }
205 
206     /***
207      * Liefert den wirksamen Marketingeffekt zur&uuml;ck
208      *
209      * @param	marketingEffekt	Der Marketingeffekt
210      * @param	erloesVorquartal	Die Umsatzerl&ouml;se des Vorquartales
211      * @param	marketingTabelle	Die Tabelle mit den Zuordnungen wirkames Marketing (t-1) / Umsatz (t-1) -> Marketingeffekt
212      * @return	Den wirksame Marketingeffekt
213      */
214     public static final double wirksamerMarketingEffekt(final double marketingEffekt, final double erloesVorquartal, final ArrayList marketingTabelle)
215     {
216         double marketingwirk_durch_erloes = 0.0;
217         double marketingwirk_durch_erloes_intervall = 0.0;
218         double marketingEffektIntervall = 0.0;
219         double marketingEffektDifferenz = 0.0;
220         double ergebnis = 0.0;
221 
222         int groesseMarketingTabelle = marketingTabelle.size();
223 
224         if (marketingEffekt > ((Marketingeffekt) marketingTabelle.get(groesseMarketingTabelle - 1)).getMarketingEffekt())
225         {
226             ergebnis = (((Marketingeffekt) marketingTabelle.get(groesseMarketingTabelle - 1)).getMarketing() * erloesVorquartal);
227         }
228         else if (marketingEffekt <= ((Marketingeffekt) marketingTabelle.get(0)).getMarketingEffekt())
229         {
230             ergebnis = ((Marketingeffekt) marketingTabelle.get(0)).getMarketing();
231         }
232 
233         // suche das entsprechende Intervall
234         for (int i = 0; i < groesseMarketingTabelle - 1; i++)
235         {
236             if ((((Marketingeffekt) marketingTabelle.get(i)).getMarketingEffekt() < marketingEffekt) && (marketingEffekt <= ((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketingEffekt()))
237             {
238                 marketingEffektDifferenz = (marketingEffekt - ((Marketingeffekt) marketingTabelle.get(i)).getMarketingEffekt());
239                 marketingwirk_durch_erloes_intervall = (((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketing() - ((Marketingeffekt) marketingTabelle.get(i)).getMarketing());
240                 marketingEffektIntervall = (((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketingEffekt() - ((Marketingeffekt) marketingTabelle.get(i)).getMarketingEffekt());
241                 // Interpolation
242                 marketingwirk_durch_erloes = ((Marketingeffekt) marketingTabelle.get(i)).getMarketing() + (marketingwirk_durch_erloes_intervall / marketingEffektIntervall * marketingEffektDifferenz);
243 
244                 ergebnis = (marketingwirk_durch_erloes * erloesVorquartal);
245             }
246         }
247 
248         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
249         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
250 
251         return rueckgabewert;
252     }
253 
254     /***
255      * Liefert den Marketingeffekt zur&uuml;ck
256      *
257      * @param	wirksamesMarketing	Das wirksame Marketing
258      * @param	erloesVorquartal	Die Umsatzerl&ouml;se des Vorquartales
259      * @param	marketingTabelle	Die Tabelle mit den Zuordnungen wirkames Marketing (t-1) / Umsatz (t-1) -> Marketingeffekt
260      * @return	Der Marketingeffekt (Die Wirkung des gemachten Marketings)
261      */
262     public static final double marketingEffekt(final double wirksamesMarketing, final double erloesVorquartal, final ArrayList marketingTabelle)
263     {
264         double marketingEffekt = 0.0;
265         double marketingwirk_durch_erloes = 0.0;
266         double marketingwirk_durch_erloes_intervall = 0.0;
267         double marketingEffektIntervall = 0.0;
268         double marketingwirk_durch_erloes_differenz = 0.0;
269         double ergebnis = 0.00;
270 
271         int groesseMarketingTabelle = marketingTabelle.size();
272 
273         if (erloesVorquartal != 0)
274         {
275             marketingwirk_durch_erloes = wirksamesMarketing / erloesVorquartal;
276         }
277         else
278         {
279             marketingwirk_durch_erloes = wirksamesMarketing;
280         }
281 
282         if (marketingwirk_durch_erloes >= ((Marketingeffekt) marketingTabelle.get(groesseMarketingTabelle - 1)).getMarketing())
283         {
284             ergebnis = ((Marketingeffekt) marketingTabelle.get(groesseMarketingTabelle - 1)).getMarketingEffekt();
285         }
286         else if (marketingwirk_durch_erloes <= ((Marketingeffekt) marketingTabelle.get(0)).getMarketing())
287         {
288             ergebnis = ((Marketingeffekt) marketingTabelle.get(0)).getMarketingEffekt();
289         }
290 
291         // suche das entsprechende Intervall
292         for (int i = 0; i < groesseMarketingTabelle - 1; i++)
293         {
294 
295             if ((((Marketingeffekt) marketingTabelle.get(i)).getMarketing() < marketingwirk_durch_erloes) && (marketingwirk_durch_erloes <= ((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketing()))
296             {
297                 marketingwirk_durch_erloes_differenz = (marketingwirk_durch_erloes - ((Marketingeffekt) marketingTabelle.get(i)).getMarketing());
298                 marketingwirk_durch_erloes_intervall = (((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketing() - ((Marketingeffekt) marketingTabelle.get(i)).getMarketing());
299                 marketingEffektIntervall = (((Marketingeffekt) marketingTabelle.get(i + 1)).getMarketingEffekt() - ((Marketingeffekt) marketingTabelle.get(i)).getMarketingEffekt());
300 
301                 marketingEffekt = ((Marketingeffekt) marketingTabelle.get(i)).getMarketingEffekt() + (marketingEffektIntervall / marketingwirk_durch_erloes_intervall * marketingwirk_durch_erloes_differenz);
302                 // Interpolation
303 
304                 ergebnis = marketingEffekt;
305             }
306         }
307 
308         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
309         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
310 
311         return rueckgabewert;
312     }
313 
314     /***
315      * Liefert den Grenzwert Marketingeffekt zur&uuml;ck
316      *
317      * @param	realerPreis	Der reale Verkaufspreis
318      * @param	neuerWirksamerPreis	Der neue wirksame Verkaufspreis
319      * @param	realerPreisVorquartal	Der reale Verkaufspreis des Vorquartals
320      * @param	praeferenzEffekt	Der Pr&auml;ferenzeffekt (Vorzug gegen&uuml;ber einem anderen Produkt)
321      * @return	Der Grenzwert Marketingeffekt (Die Wirkung des gemachten Marketings)
322      */
323     public static final double grenzMarketingEffekt(final double realerPreis, final double neuerWirksamerPreis, final double realerPreisVorquartal, final double praeferenzEffekt)
324     {
325         double ergebnis = (realerPreis / ((neuerWirksamerPreis - (realerPreis - realerPreisVorquartal) * (realerPreis - realerPreisVorquartal)) * (1.0 + praeferenzEffekt)) - 1.0);
326 
327         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
328         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
329 
330         return rueckgabewert;
331     }
332 
333     /***
334      * Liefert das nominelle Marketing zur&uuml;ck
335      *
336      * @param	realesMarketing	Der reale Marketingaufwand
337      * @param	inflationsIndex	Der aktuelle Inflationsindex
338      * @return	Der nominelle Marketingaufwand
339      */
340     public static final double nominellesMarketing(final double realesMarketing, final double inflationsIndex)
341     {
342         double ergebnis = (realesMarketing * inflationsIndex);
343 
344         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
345         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
346 
347         return rueckgabewert;
348     }
349 
350     /***
351      * Liefert den Absatz gem&auml;ß Preis-Absatz Funktion zur&uuml;ck
352      *
353      * @param	wirksamerPreis	Der wirksame Preis
354      * @param	preisAbsatzTabelle	Die Array Liste mit den Preis - Absatz Zuordnungen
355      * @return	Den Absatz gem&auml;ß Preis-Absatz Funktion
356      */
357     public static final double pafAbsatz(final double wirksamerPreis, final ArrayList preisAbsatzTabelle)
358     {
359         double ergebnis = 0.0;
360 
361         double preisDifferenz = 0.0;
362         double preisIntervall = 0.0;
363         double absatzIntervall = 0.0;
364         double absatzPotential = 0.0;
365 
366         int groessePreisAbsatzTabelle = preisAbsatzTabelle.size();
367 
368         if (wirksamerPreis <= ((PreisAbsatz) preisAbsatzTabelle.get(0)).getPreis())
369         {
370             ergebnis = ((PreisAbsatz) preisAbsatzTabelle.get(0)).getAbsatz();
371         }
372         else if (wirksamerPreis >= ((PreisAbsatz) preisAbsatzTabelle.get(groessePreisAbsatzTabelle - 1)).getPreis())
373         {
374             ergebnis = ((PreisAbsatz) preisAbsatzTabelle.get(groessePreisAbsatzTabelle - 1)).getAbsatz();
375         }
376 
377         for (int i = 0; i < groessePreisAbsatzTabelle - 1; i++)
378         { // suche das entsprechende Intervall
379             if ((((PreisAbsatz) preisAbsatzTabelle.get(i)).getPreis() < wirksamerPreis) && (wirksamerPreis <= ((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getPreis()))
380             {
381                 // in Cent
382                 preisDifferenz = (wirksamerPreis - ((PreisAbsatz) preisAbsatzTabelle.get(i)).getPreis()) * Konstanten.HUNDRED_PERCENT;
383                 preisIntervall = (((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getPreis() - ((PreisAbsatz) preisAbsatzTabelle.get(i)).getPreis()) * Konstanten.HUNDRED_PERCENT;
384                 absatzIntervall = (((PreisAbsatz) preisAbsatzTabelle.get(i)).getAbsatz() - ((PreisAbsatz) preisAbsatzTabelle.get(i + 1)).getAbsatz());
385 
386                 // Interpolation
387                 absatzPotential = ((PreisAbsatz) preisAbsatzTabelle.get(i)).getAbsatz() - (absatzIntervall / preisIntervall * preisDifferenz);
388 
389                 ergebnis = absatzPotential;
390             }
391         }
392 
393         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
394         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
395 
396         return rueckgabewert;
397 
398     }
399 
400     /***
401      * Liefert die Grenz-Marketingkosten zur&uuml;ck
402      *
403      * @param	konjunkturIndex	Der Konjunkturindex
404      * @param	saisonIndex	Der Saisonindex
405      * @param	absetzbareMenge	Die absetzbare Menge an Fertigrpodukten
406      * @param	wirksamerPreis	Der wirksame Verkaufspreis
407      * @param	realerPreisAktuell	Der aktuelle reale Verkaufspreis
408      * @param	realerPreisVorquartal	Der reale Verkaufspreis	im Vorquartal
409      * @param	praeferenzeffekt	Der Pr&auml;ferenzeffekt eines Produktes dieser Firma gegen&uuml;ber einem der anderen Firma
410      * @param	erloesVorquartal	Die Umsatzerl&ouml;se aus dem Vorquartal
411      * @param	wirksamesMarketingVorquartal	Die wirksamen Marketingausgaben im Vorquartal
412      * @param	inflationsIndex	Der Inflationsindex
413      * @param	nachhall	Der Nachhall von Marketingaufwendungen
414      * @param	wirksamesMarketing	Die wirksamen Marketingausgaben
415      * @param	korrektur	Der Korrektufaktor
416      * @param	preisAbsatzTabelle	Die Array Liste mit den Preis - Absatz Zuordnungen
417      * @param	marketingTabelle	Die Tabelle mit den Zuordnungen wirkames Marketing (t-1) / Umsatz (t-1) -> Marketingeffekt
418      * @param	anzahlUnternehmen	Die Anzahl der Unternehmen bei dieser Berechnung
419      * @return	Die Grenz-Marketingkosten
420      */
421     public static final double grenzMarketingKosten(
422         final double konjunkturIndex,
423         final double saisonIndex,
424         final double absetzbareMenge,
425         final double wirksamerPreis,
426         final double realerPreisAktuell,
427         final double realerPreisVorquartal,
428         final double praeferenzeffekt,
429         final double erloesVorquartal,
430         final double wirksamesMarketingVorquartal,
431         final double inflationsIndex,
432         final double nachhall,
433         final double wirksamesMarketing,
434         final double korrektur,
435         final ArrayList preisAbsatzTabelle,
436         final ArrayList marketingTabelle,
437         final int anzahlUnternehmen)
438     {
439         double ergebnis = 0.0;
440 
441         double absatzNeu = 0.0, wirksamerPreisNeu = 0.0, grenzMarketingEffektNeu = 0.0, wirksamesMarketingNeu = 0.0, deltaRealesMarketingNeu = 0.0, deltaNominellesMarketingNeu = 0.0, deltaWirksamesMarketing = 0.0;
442 
443         // diese Variablen werden ben&ouml;tigt, wenn der Korrekturfaktor < 1 ist!
444         double preisDurchschnitt = 0.0, korrekturNeu = 0.0, absetzbareMengeDifferenz = 0.0;
445 
446         // die 10000 zuletzt verkauften St&uuml;ck
447         absatzNeu = (pafAbsatz(wirksamerPreis, preisAbsatzTabelle) - (10000.0 / (konjunkturIndex * saisonIndex * korrektur)));
448         // den ohne diese 10000 ben&ouml;tigte wirksame Preis
449         wirksamerPreisNeu = pafWirksamerPreis(absatzNeu, preisAbsatzTabelle);
450         // den daraus resultierenden Marketingeffekt berechnen
451         grenzMarketingEffektNeu = grenzMarketingEffekt(realerPreisAktuell, wirksamerPreisNeu, realerPreisVorquartal, praeferenzeffekt);
452         // die daraus resultierenden wirksamen Marketingaufwendungen
453         wirksamesMarketingNeu = wirksamerMarketingEffekt(grenzMarketingEffektNeu, erloesVorquartal, marketingTabelle);
454         // wirksame Marketingdifferenz
455         deltaWirksamesMarketing = wirksamesMarketing - wirksamesMarketingNeu;
456         // neue reale Marketingdifferenz
457         deltaRealesMarketingNeu = deltaWirksamesMarketing;
458 
459         // Ber&uuml;cksichtigung des Korrekturfaktors
460         if (korrektur < 1.0)
461         {
462             preisDurchschnitt = (wirksamerPreis * Math.sqrt(korrektur));
463 
464             // neuen Korrekturfaktor berechnen
465             korrekturNeu = (((preisDurchschnitt * anzahlUnternehmen) - wirksamerPreis + wirksamerPreisNeu) / (double) anzahlUnternehmen) / wirksamerPreisNeu;
466             korrekturNeu *= korrekturNeu;
467 
468             // Differenz der absetzbaren Menge
469             if (absetzbareMenge > 0.0)
470             {
471                 absetzbareMengeDifferenz = (absetzbareMenge / korrektur * korrekturNeu) - absetzbareMenge;
472             }
473             else
474             {
475                 absetzbareMengeDifferenz = (1.0 / korrektur * korrekturNeu) - absetzbareMenge;
476             }
477 
478             // Differenz in Bezug auf die gesamte absetzbre Menge
479             if (absetzbareMenge > 0.0)
480             {
481                 absetzbareMengeDifferenz /= absetzbareMenge;
482             }
483             else
484             {
485                 absetzbareMengeDifferenz /= 1.0;
486             }
487 
488             // an reale Marketingdifferenz anpassen
489             deltaRealesMarketingNeu /= (1.0 + absetzbareMengeDifferenz);
490         }
491 
492         // neue nominale Marketingdifferenz
493         deltaNominellesMarketingNeu = nominellesMarketing(deltaRealesMarketingNeu, inflationsIndex);
494 
495         // Grenzmarketingkosten
496         if ((deltaNominellesMarketingNeu / 10000.0) > 0.0)
497         {
498             ergebnis = - (deltaNominellesMarketingNeu / 10000.0);
499         }
500         else
501         {
502             ergebnis = (deltaNominellesMarketingNeu / 10000.0);
503         }
504 
505         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
506         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
507 
508         return rueckgabewert;
509     }
510 
511     /***
512      * Liefert die absetzbare Menge zur&uuml;ck
513      * Ohne Ber&uuml;chsichtigung des Defizits anderer Unternehmen
514      *
515      * @param	absatzpotential	Absatzpotential laut Preis-Absatz-Funktion
516      * @param	konjunkturIndex	Der Konjunkturindex
517      * @param	saisonIndex	Der Saisonindex
518      * @param	korrekturFaktor	Der Korrekturfaktor
519      * @return	Die absetzbare Menge
520      */
521     public static final double mengeAbsetzbar(final double absatzpotential, final double konjunkturIndex, final double saisonIndex, final double korrekturFaktor)
522     {
523         double ergebnis = (absatzpotential * konjunkturIndex * saisonIndex * korrekturFaktor);
524 
525         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
526         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
527 
528         return rueckgabewert;
529     }
530 
531     /***
532      * Liefert das auf dieses Unternehmen entfallende Plus an m&ouml;glichem Absatz durch das Defizit der anderen Unternehmen zur&uuml;ck
533      * Tabelle 20 Zeile 222
534      *
535      * @param	gesamtesDefizitAndererUnternehmen	Kummuliertes Lieferdefizit der anderen Unternehmen
536      * @param	absetzbareMengenTabelle	Die absetzbaren Mengen aller Mitspieler vor Ber&uuml;cksichtigung der Defizite anderer Unternehmen
537      * @param	gruppennummer	Mitspieler f&uuml;r den der Wert errechnet werden soll
538      * @return	Zus&auml;tzliche Absatzm&ouml;glichkeit in St&uuml;ck
539      */
540     public static final double zusaetzlicherAbsatzDurchDefizitAndererUnternehmen(final double gesamtesDefizitAndererUnternehmen, final ArrayList absetzbareMengenTabelle, final Integer gruppennummer)
541     {
542         double ergebnis = 0.0;
543 
544         double absetzbareMengenGesamt = 0.0;
545 
546         int groesseAbsetzbareMengenTabelle = absetzbareMengenTabelle.size();
547 
548         GruppeWert absetzbareMenge = null;
549         int index = -1;
550 
551         for (int i = 0; i < groesseAbsetzbareMengenTabelle; i++)
552         {
553             absetzbareMenge = (GruppeWert) absetzbareMengenTabelle.get(i);
554 
555             absetzbareMengenGesamt = absetzbareMengenGesamt + absetzbareMenge.getWert().doubleValue();
556 
557             if (absetzbareMenge.getGruppennummer().compareTo(gruppennummer) == 0)
558             {
559                 index = i;
560             }
561         }
562 
563         absetzbareMenge = (GruppeWert) absetzbareMengenTabelle.get(index);
564 
565         if (groesseAbsetzbareMengenTabelle == 1)
566         {
567             ergebnis = 0.0;
568         }
569         else if (absetzbareMengenGesamt > 0)
570         {
571             ergebnis = ((absetzbareMenge.getWert().doubleValue() / absetzbareMengenGesamt) * gesamtesDefizitAndererUnternehmen);
572         }
573         else
574         {
575             ergebnis = ((absetzbareMenge.getWert().doubleValue()) * gesamtesDefizitAndererUnternehmen);
576         }
577 
578         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
579         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
580 
581         return rueckgabewert;
582     }
583 
584     /***
585      * Liefert die absetzbare Menge inklusive dem auf dieses Unternehmen entfallende Plus an m&ouml;glichem Absatz durch das Lieferdefizit der anderen Unternehmen zur&uuml;ck
586      * Tabelle 20 Zeile: 221
587      *
588      * @param	pafAbsatz	M&ouml;glicher Absatz gem&auml;ß Preis-Absatz Funktion
589      * @param	konjunkturIndex	Der Konjunkturindex
590      * @param	saisonIndex	Der Saisonindex
591      * @param	korrekturFaktor	Der Korrekturfaktor
592      * @param	defizitAndererUnternehmen	&uuml;bergabe des Defizits anderer Unternehmen erfolgt aus den Berechnungen f&uuml;r die Zeile 222
593      * @return	absetzbare Menge inklusive dem durch Defizit entstehenden zus&auml;tzlichen Absatz
594      */
595     public static final double mengeAbsetzbarInklusiveZusaetzlichemAbsatzDurchDefizitAndererUnternehmen(final double pafAbsatz, final double konjunkturIndex, final double saisonIndex, final double korrekturFaktor, final double defizitAndererUnternehmen)
596     {
597         double ergebnis = (pafAbsatz * konjunkturIndex * saisonIndex * korrekturFaktor + defizitAndererUnternehmen);
598 
599         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
600         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
601 
602         return rueckgabewert;
603     }
604 
605     /***
606      * Liefert den PAF Absatz - bezogen auf Saison + Konjunktur + Korrektur  zur&uuml;ck
607      *
608      * @param	saisonIndex	Der Saisonindex
609      * @param	konjunkturIndex	Der Konjunkturindex
610      * @param	pafAbsatzPotential	Das durch pafAbsatz() Absatzpotential
611      * @param	korrekturFaktor	Der Korrekturfaktor
612      * @return	Das durch die Indizes verminderte Absatzpotential
613      */
614     public static final double minderAbsatz(final double saisonIndex, final double konjunkturIndex, final double pafAbsatzPotential, final double korrekturFaktor)
615     {
616         double ergebnis = (saisonIndex * konjunkturIndex * pafAbsatzPotential * (1 - korrekturFaktor));
617 
618         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
619         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
620 
621         return rueckgabewert;
622     }
623 
624     /***
625      * Liefert die Gesamtmenge aus produzierten und gelagerten Fertigprodukten zur&uuml;ck
626      *
627      * @param	guteProduktionsmenge	Die St&uuml;ckzahl an guten produzierten Fertigprodukten
628      * @param	lagerbestandFertigprodukte	Die St&uuml;ckzahl an guten gelagerten Fertigprodukten
629      * @return	Die Gesamtmenge aus produzierten und gelagerten Fertigprodukten
630      */
631     public static final double fertigProdukteGesamt(final double guteProduktionsmenge, final double lagerbestandFertigprodukte)
632     {
633         double ergebnis = (guteProduktionsmenge + lagerbestandFertigprodukte);
634 
635         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
636         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
637 
638         return rueckgabewert;
639     }
640 
641     /***
642      * Liefert das Lieferdefizit ohne Ber&uuml;cksichtigung der noch nicht bekannten Lieferdefizite der Mitbewerber zur&uuml;ck
643      * Tabelle 20 Zeile 225
644      *
645      * @param	fertigProdukteGesamt	Die durch fertigProdukteGesamt() errrechnete Gesamtmenge aus produzierten und gelagerten Fertigprodukten
646      * @param	absetzbareMenge	Die Anzahl von absetzbaren Produkten
647      * @return	Das Lieferdefizit
648      */
649     public static final double defizit(final double fertigProdukteGesamt, final double absetzbareMenge)
650     {
651         double ergebnis = (absetzbareMenge - fertigProdukteGesamt);
652 
653         if (ergebnis < 0.0)
654         {
655             ergebnis = 0.0;
656         }
657 
658         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
659         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
660 
661         return rueckgabewert;
662     }
663 
664     /***
665      * Liefert das kummulierte Defizit aller Unternehmen zur&uuml;ck.
666      *
667      * @param   fertigProdukteTabelle   Tabelle mit der Menge des Fertigproduktbestandes jedes teilnehmenden Unternehmens
668      * @param   absetzbareMengenTabelle Tabelle mit den absetzbaren Mengen jedes teilnehmenden Unternehmens
669      * @param   gruppennummer   Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Wert ausgerechnet werden soll
670      * @return  Das kummulierte Defizit aller Unternehmen
671      */
672     public static final double defizitAndererUnternehmenGesamt(final ArrayList fertigProdukteTabelle, final ArrayList absetzbareMengenTabelle, final Integer gruppennummer)
673     {
674         double differenzGesamt = 0.0;
675 
676         int groesseAbsetzbareMengenTabelle = absetzbareMengenTabelle.size();
677 
678         GruppeWert fertigprodukte = null;
679         GruppeWert absetzbaremenge = null;
680 
681         for (int i = 0; i < groesseAbsetzbareMengenTabelle; i++)
682         {
683             fertigprodukte = (GruppeWert) fertigProdukteTabelle.get(i);
684 
685             if (fertigprodukte.getGruppennummer().compareTo(gruppennummer) != 0)
686             {
687                 for (int j = 0; j < groesseAbsetzbareMengenTabelle; j++)
688                 {
689                     absetzbaremenge = (GruppeWert) absetzbareMengenTabelle.get(j);
690 
691                     if (fertigprodukte.getGruppennummer().compareTo(absetzbaremenge.getGruppennummer()) == 0 && absetzbaremenge.getGruppennummer().compareTo(gruppennummer) != 0)
692                     {
693                         differenzGesamt += defizit(fertigprodukte.getWert().doubleValue(), absetzbaremenge.getWert().doubleValue());
694                     }
695                 }
696             }
697         }
698 
699         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
700         double rueckgabewert = Common.aufZehnNachkommastellenRunden(differenzGesamt / 2.0);
701 
702         return rueckgabewert;
703     }
704 
705     /***
706      * Liefert das kummulierte Defizit aller Unternehmen zur&uuml;ck, zu 50%, nur die H&auml;lfte wird weiter verteilt.
707      *
708      * @param   fertigProdukteTabelle   Tabelle mit der Menge des Fertigproduktbestandes jedes teilnehmenden Unternehmens
709      * @param   absetzbareMengenTabelle Tabelle mit den absetzbaren Mengen jedes teilnehmenden Unternehmens
710      * @param   gruppennummer   Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Wert ausgerechnet werden soll
711      * @return  Das kummulierte Defizit aller Unternehmen
712      */
713     public static final double defizitAndererUnternehmen(final ArrayList fertigProdukteTabelle, final ArrayList absetzbareMengenTabelle, final Integer gruppennummer)
714     {
715         double ergebnis = 0.0;
716 
717         double differenzGesamt = 0.0;
718 
719         int groesseAbsetzbareMengenTabelle = absetzbareMengenTabelle.size();
720 
721         GruppeWert fertigprodukte = null;
722         GruppeWert absetzbaremenge = null;
723         double fertigprodukteGesamt = 0.0;
724         double absetzbaremengenGesamt = 0.0;
725         int index = -1;
726 
727         for (int i = 0; i < groesseAbsetzbareMengenTabelle; i++)
728         {
729             fertigprodukte = (GruppeWert) fertigProdukteTabelle.get(i);
730             absetzbaremenge = (GruppeWert) absetzbareMengenTabelle.get(i);
731 
732             fertigprodukteGesamt += fertigprodukte.getWert().doubleValue();
733             absetzbaremengenGesamt += absetzbaremenge.getWert().doubleValue();
734 
735             if (fertigprodukte.getGruppennummer().compareTo(gruppennummer) != 0 && absetzbaremenge.getGruppennummer().compareTo(gruppennummer) != 0)
736             {
737                 differenzGesamt += defizit(fertigprodukte.getWert().doubleValue(), absetzbaremenge.getWert().doubleValue());
738             }
739 
740             if (fertigprodukte.getGruppennummer().compareTo(gruppennummer) == 0 && absetzbaremenge.getGruppennummer().compareTo(gruppennummer) == 0)
741             {
742                 index = i;
743             }
744         }
745 
746         absetzbaremenge = (GruppeWert) absetzbareMengenTabelle.get(index);
747 
748         // nur 50% werden auf andere Unternehmen verteilt
749         differenzGesamt /= 2.0;
750 
751         if (fertigprodukte.getGruppennummer().compareTo(gruppennummer) != 0 && absetzbaremenge.getGruppennummer().compareTo(gruppennummer) == 0 && absetzbaremengenGesamt > 0.0)
752         {
753             ergebnis = (absetzbaremenge.getWert().doubleValue() / absetzbaremengenGesamt) * differenzGesamt;
754         }
755         else if (fertigprodukte.getGruppennummer().compareTo(gruppennummer) != 0 && absetzbaremenge.getGruppennummer().compareTo(gruppennummer) == 0 && absetzbaremengenGesamt == 0.0)
756         {
757             ergebnis = differenzGesamt;
758         }
759 
760         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
761         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
762 
763         return rueckgabewert;
764     }
765 
766     /***
767      * Liefert den tats&auml;chlichen Absatz (Minimum aus absetzbareMenge und fertigProdukteGesamt) zur&uuml;ck
768      * Tabelle 20 Zeile 224
769      * absetzbare Menge ber&uuml;cksichtigt berreits das Lieferdefizit anderer Unternehmen
770      *
771      * @param	absetzbareMenge	Die absetzbare Menge
772      * @param	fertigProdukteGesamt	Die Menge der verf&uuml;gbaren Fertigprodukte
773      * @return	Der tats&auml;chliche Absatz
774      */
775     public static final double tatsaechlicherAbsatz(final double absetzbareMenge, final double fertigProdukteGesamt)
776     {
777         double ergebnis = Math.min(absetzbareMenge, fertigProdukteGesamt);
778 
779         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
780         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
781 
782         return rueckgabewert;
783     }
784 
785     /***
786      * Liefert den Lagerzugang an Fertigprodukten in St&uuml;ck zur&uuml;ck
787      * Tabelle 20 Zeile 231
788      *
789      * @param	absetzbareMenge	Die absetzbare Menge an Fertigprodukten in St&uuml;ck
790      * @param	guteProduktionsMenge	Die Produktionsmenge an Fertigprodukten in St&uuml;ck
791      * @return	Lagerzugang an Fertigprodukten
792      */
793     public static final double lagerZugangFertigprodukteStueck(final double absetzbareMenge, final double guteProduktionsMenge)
794     {
795         double ergebnis = 0.0;
796 
797         if (guteProduktionsMenge > absetzbareMenge)
798         {
799             ergebnis = (guteProduktionsMenge - absetzbareMenge);
800         }
801         else
802         {
803             ergebnis = 0.0;
804         }
805 
806         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
807         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
808 
809         return rueckgabewert;
810     }
811 
812     /***
813      * Liefert den Lagerabgang an Fertigprodukten in St&uuml;ck zur&uuml;ck
814      * Tabelle 20 Zeile 232
815      *
816      * @param	absetzbareMenge	Die absetzbare Menge an Produkten
817      * @param	guteProduktionsMenge	Die Produktionsmenge in guten St&uuml;ck
818      * @param	lagerBestandFertigprodukteStueck	Der vorhandene Lagerbestand an Fertigprodukten
819      * @return	Der Lagerabgang an Fertigprodukten
820      */
821     public static final double lagerAbgangFertigprodukteStueck(final double absetzbareMenge, final double guteProduktionsMenge, final double lagerBestandFertigprodukteStueck)
822     {
823         double ergebnis = 0.0;
824 
825         if (lagerBestandFertigprodukteStueck > 0)
826         {
827             if (- (guteProduktionsMenge - absetzbareMenge) > lagerBestandFertigprodukteStueck)
828             {
829                 ergebnis = (lagerBestandFertigprodukteStueck);
830             }
831             else
832             {
833                 if (- (guteProduktionsMenge - absetzbareMenge) > 0)
834                 {
835                     ergebnis = (- (guteProduktionsMenge - absetzbareMenge));
836                 }
837                 else
838                 {
839                     ergebnis = 0.0;
840                 }
841             }
842         }
843         else
844         {
845             ergebnis = 0.0;
846         }
847 
848         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
849         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
850 
851         return rueckgabewert;
852     }
853 
854     /***
855      * Liefert den Lagerbestand an Fertigprodukte in St&uuml;ck zur&uuml;ck
856      * Tabelle 20 Zeile 233
857      *
858      * @param	lagerBestandFertigprodukteStueckVorquartal	Der Lagerbestand an Fertigprodukten im Vorquartal
859      * @param	lagerAbgangFertigprodukteStueck	Der Lagerabgang an Fertigprodukten
860      * @param	lagerZugangFertigprodukteStueck	Der Lagerzugang an Fertigprodukten
861      * @return	Der Lagerbestand an Fertigprodukten
862      */
863     public static final double lagerBestandFertigprodukteStueck(final double lagerBestandFertigprodukteStueckVorquartal, final double lagerAbgangFertigprodukteStueck, final double lagerZugangFertigprodukteStueck)
864     {
865         double ergebnis = (lagerBestandFertigprodukteStueckVorquartal - lagerAbgangFertigprodukteStueck + lagerZugangFertigprodukteStueck);
866 
867         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
868         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
869 
870         return rueckgabewert;
871     }
872 
873     /***
874      * Liefert die Rohstoffkosten pro gutes produziertes St&uuml;ck zur&uuml;ck
875      * Ausschuss in Prozent
876      *
877      * @param	rohstoffverbrauchProFertigprodukt		Der Rohstoffverbrauch pro Fertigprodukt
878      * @param	rohstoffkostenProStueck	Die Rohstoffkosten pro Fertigprodukt
879      * @param	ausschuss	Der prozentuale Ausschussanteil
880      * @return	Die Rohstoffkosten pro gutes produziertes St&uuml;ck
881      */
882     public static final double rohstoffKostenProGutesStueck(final double rohstoffverbrauchProFertigprodukt, final double rohstoffkostenProStueck, final double ausschuss)
883     {
884         double ausschussTemp = ausschuss / Konstanten.HUNDRED_PERCENT;
885 
886         double ergebnis = (rohstoffverbrauchProFertigprodukt * rohstoffkostenProStueck / (1.0 - ausschussTemp));
887 
888         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
889         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
890 
891         return rueckgabewert;
892     }
893 
894     /***
895      * Liefert die Lohnkosten pro gutes produziertes St&uuml;ck zur&uuml;ck
896      *
897      * @param	fertigungsstueckzeit	Die ben&ouml;tigte Zeit um ein Produkt fertigzustellen in Minuten
898      * @param	lohnkostenReal	Die realen Lohnkosten in Euro
899      * @param	fehleranteil	Der Fehleranteil bei der Produktion In Prozent (0.0 - 100.0)
900      * @param	nacharbeitsAufwand	Der Aufwand um ein fehlerbehaftetes St&uuml;ck nachzuarbeiten In Prozent (0.0 - 100.0)
901      * @return	Die Lohnkosten pro gutes produziertes St&uuml;ck
902      */
903     public static final double lohnkostenProGutesStueck(final double fertigungsstueckzeit, final double lohnkostenReal, final double fehleranteil, final double nacharbeitsAufwand)
904     {
905         double fehleranteilTemp = fehleranteil / Konstanten.HUNDRED_PERCENT;
906         double nacharbeitsAufwandTemp = nacharbeitsAufwand / Konstanten.HUNDRED_PERCENT;
907 
908         double ergebnis = (fertigungsstueckzeit / 60.0 * lohnkostenReal * (1.0 + fehleranteilTemp * 0.75 * nacharbeitsAufwandTemp) / (1.0 - fehleranteilTemp * 0.25));
909 
910         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
911         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
912 
913         return rueckgabewert;
914     }
915 
916     /***
917      * Liefert die Kosten pro Fertigprodukt zur&uuml;ck
918      *
919      * @param	lohnkostenMitErhoehung	Die Lohnkosten mit bereits eingerechneter Lohnerh&ouml;hung
920      * @param	fertigungszeitProGutesStueck	Die Fertigungszeit pro gutem St&uuml;ck
921      * @param	rohstoffverbrauchProStueck		Der Rohstoffverbrauch pro gutem St&uuml;ck
922      * @param	fehleranteil	Der Fehleranteil bei der Produktion
923      * @param	rohstofflagerWert	Der Wert der im Lager befindlichen Rohstoffe
924      * @param	rohstoffEinkaufExpressWert	Der Wert der per Express eingekauften Rohstoffe
925      * @param	rohstofflagerMenge	Die Lagermenge an Rohstoffen
926      * @return	Die Kosten pro Fertigprodukt
927      */
928     public static final double kostenProFertigprodukt(final double lohnkostenMitErhoehung, final double fertigungszeitProGutesStueck, final double rohstoffverbrauchProStueck, final double fehleranteil, final double rohstofflagerWert, final double rohstoffEinkaufExpressWert, final double rohstofflagerMenge)
929     {
930         double fehleranteilTemp = fehleranteil / Konstanten.HUNDRED_PERCENT;
931 
932         double ergebnis = 0.0;
933 
934         if (rohstofflagerMenge > 0)
935         {
936             ergebnis = ((lohnkostenMitErhoehung * (fertigungszeitProGutesStueck / 60.0)) + ((rohstoffverbrauchProStueck / (1.0 - fehleranteilTemp * 0.25)) * ((rohstofflagerWert + rohstoffEinkaufExpressWert) / rohstofflagerMenge)));
937         }
938         else
939         {
940             ergebnis = ((lohnkostenMitErhoehung * (fertigungszeitProGutesStueck / 60.0)) + ((rohstoffverbrauchProStueck / (1.0 - fehleranteilTemp * 0.25)) * (rohstofflagerWert + rohstoffEinkaufExpressWert)));
941         }
942 
943         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
944         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
945 
946         return rueckgabewert;
947     }
948 
949     /***
950      * Liefert den Wert des Lagerzugangs an Fertigprodukten zur&uuml;ck
951      * Tabelle 21 Zeile 13
952      *
953      * @param	lagerZugangFertigprodukteStueck	Der Lagerzugang an Fertigprodukten in St&uuml;ck
954      * @param	kostenProFertigprodukt	Die aufgewendeten Kosten pro Fertigprodukt
955      * @return	Wert des Lagerzugangs an Fertigprodukten
956      */
957     public static final double lagerZugangFertigprodukteEuro(final double lagerZugangFertigprodukteStueck, final double kostenProFertigprodukt)
958     {
959         double ergebnis = (lagerZugangFertigprodukteStueck * kostenProFertigprodukt);
960 
961         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
962         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
963 
964         return rueckgabewert;
965     }
966 
967     /***
968      * Liefert den durchschnittlichen Wert eines Fertigproduktes im Lager zur&uuml;ck
969      *
970      * @param	lagerBestandFertigprodukteStueckVorquartal	Der Lagerbestand an Fertigprodukten im Vorquartal
971      * @param	lagerBestandFertigprodukteEuroVorquartal	Der Wert des Lagerbestands an Fertigprodukten im Vorquartal
972      * @return	Der durchschnittliche Wert eines Fertigproduktes im Lager
973      */
974     public static final double durchschnittlicherWertFertigprodukteLager(final double lagerBestandFertigprodukteStueckVorquartal, final double lagerBestandFertigprodukteEuroVorquartal)
975     {
976         double ergebnis = 0.0;
977 
978         if (lagerBestandFertigprodukteEuroVorquartal > 0 && lagerBestandFertigprodukteStueckVorquartal > 0)
979         {
980             ergebnis = (lagerBestandFertigprodukteEuroVorquartal / lagerBestandFertigprodukteStueckVorquartal);
981         }
982         else
983         {
984             ergebnis = 0.0;
985         }
986 
987         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
988         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
989 
990         return rueckgabewert;
991     }
992 
993     /***
994      * Liefert den Wert des Lagerabgangs an Fertigprodukten zur&uuml;ck
995      * Tabelle 21 Zeile 17
996      *
997      * @param	durchschnittlicherWertFertigprodukteLager	Der durchschnittliche Wert eines Fertigproduktes im Lager
998      * @param	lagerAbgangFertigprodukteStueck	Der Lagerabgang an Fertigprodukten in St&uuml;ck
999      * @return	Wert des Lagerabgangs an Fertigprodukten
1000      */
1001     public static final double lagerAbgangFertigprodukteEuro(final double durchschnittlicherWertFertigprodukteLager, final double lagerAbgangFertigprodukteStueck)
1002     {
1003         double ergebnis = (lagerAbgangFertigprodukteStueck * durchschnittlicherWertFertigprodukteLager);
1004 
1005         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1006         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1007 
1008         return rueckgabewert;
1009     }
1010 
1011     /***
1012      * Liefert den Wert des Lagerbestands an Fertigprodukten zur&uuml;ck
1013      * Tabelle 22 Zeile 13
1014      *
1015      * @param	lagerBestandFertigprodukteEuroVorquartal	Der Wert des Lagerbestands an Fertigprodukten im Vorquartal
1016      * @param	lagerZugangFertigprodukteEuro	Wert des Lagerzugangs an Fertigprodukten
1017      * @param	lagerAbgangFertigprodukteEuro	Wert des Lagerabgangs an Fertigprodukten
1018      * @return	Wert des Lagerbestands an Fertigprodukten
1019      */
1020     public static final double lagerBestandFertigprodukteEuro(final double lagerBestandFertigprodukteEuroVorquartal, final double lagerZugangFertigprodukteEuro, final double lagerAbgangFertigprodukteEuro)
1021     {
1022         double ergebnis = (lagerBestandFertigprodukteEuroVorquartal + lagerZugangFertigprodukteEuro - lagerAbgangFertigprodukteEuro);
1023 
1024         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1025         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1026 
1027         return rueckgabewert;
1028     }
1029 
1030     /***
1031      * Liefert die Lagerkosten f&uuml;r die im Lager befindlichen Fertigprodukte zur&uuml;ck
1032      * Tabelle 21 Zeile 15
1033      *
1034      * @param	lagerBestandFertigprodukteStueck	Der Lagerbestand an Fertigprodukten in St&uuml;ck
1035      * @param	lagerKosten	Kosten f&uuml;r die Lagerung der Fertigprodukte pro St&uuml;ck
1036      * @return	Die Lagerkosten f&uuml;r die im Lager befindlichen Fertigprodukte
1037      */
1038     public static final double lagerKostenFertigprodukte(final double lagerBestandFertigprodukteStueck, final double lagerKosten)
1039     {
1040         double ergebnis = (lagerBestandFertigprodukteStueck * lagerKosten);
1041 
1042         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1043         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1044 
1045         return rueckgabewert;
1046     }
1047 
1048     /***
1049      * Liefert den Wert des Lagerbestands an Rohstoffen zur&uuml;ck
1050      * Tabelle 22 Zeile 12
1051      *
1052      * @param	rohstoffLagerBestandEndeQuartal	Der Rohstofflagerbestand am Ende des Quartals
1053      * @param	rohstoffWertEndeQuartal	Der Wert der Rohstoffe am Ende des Quartals
1054      * @return	Wert des Lagerbestands an Rohstoffen
1055      */
1056     public static final double rohstoffLagerBestandEuro(final double rohstoffLagerBestandEndeQuartal, final double rohstoffWertEndeQuartal)
1057     {
1058         double ergebnis = (rohstoffLagerBestandEndeQuartal * rohstoffWertEndeQuartal);
1059 
1060         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1061         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1062 
1063         return rueckgabewert;
1064     }
1065 
1066     /***
1067      * Liefert den Marktanteil des durch den Index spezifizierten Unternehmens zur&uuml;ck
1068      * Tabelle 20 Zeile 241
1069      *
1070      * @param	tatsaechlicherAbsatzTabelle	Die ArrayList mit den tats&auml;chlichen Abs&auml;tzen der Unternehmen
1071      * @param   gruppennummer   Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Wert ausgerechnet werden soll
1072      * @return	Der Marktanteil des durch den Index spezifizierten Unternehmens
1073      */
1074     public static final double marktAnteil(final ArrayList tatsaechlicherAbsatzTabelle, final Integer gruppennummer)
1075     {
1076         double ergebnis = 0.0;
1077 
1078         double absatzTatsaechlichGesamt = 0;
1079 
1080         int groesseTatsaechlicherAbsatzTabelle = tatsaechlicherAbsatzTabelle.size();
1081 
1082         GruppeWert gw = null;
1083         int index = -1;
1084 
1085         for (int i = 0; i < groesseTatsaechlicherAbsatzTabelle; i++)
1086         {
1087             gw = (GruppeWert) tatsaechlicherAbsatzTabelle.get(i);
1088 
1089             absatzTatsaechlichGesamt += gw.getWert().doubleValue();
1090 
1091             if (gw.getGruppennummer().compareTo(gruppennummer) == 0)
1092             {
1093                 index = i;
1094             }
1095         }
1096 
1097         gw = (GruppeWert) tatsaechlicherAbsatzTabelle.get(index);
1098 
1099         if (groesseTatsaechlicherAbsatzTabelle == 1)
1100         {
1101             ergebnis = Konstanten.HUNDRED_PERCENT;
1102         }
1103         else if (absatzTatsaechlichGesamt > 0)
1104         {
1105             ergebnis = ((gw.getWert().doubleValue() / absatzTatsaechlichGesamt) * Konstanten.HUNDRED_PERCENT);
1106         }
1107         else
1108         {
1109             ergebnis = (gw.getWert().doubleValue() * Konstanten.HUNDRED_PERCENT);
1110         }
1111 
1112         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1113         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1114 
1115         return rueckgabewert;
1116     }
1117 
1118     /***
1119      * Liefert den Umsatzanteil des durch den Index spezifizierten Unternehmens zur&uuml;ck
1120      * Tabelle 20 Zeile 242
1121      *
1122      * @param	umsatzTabelle	Die ArrayList mit den Ums&auml;tzen der Unternehmen
1123      * @param   gruppennummer   Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Wert ausgerechnet werden soll
1124      * @return	Der Umsatzanteil des durch den Index spezifizierten Unternehmens
1125      */
1126     public static final double umsatzAnteil(final ArrayList umsatzTabelle, final Integer gruppennummer)
1127     {
1128         double ergebnis = 0.0;
1129 
1130         double umsatzGesamt = 0.0;
1131 
1132         int groesseUmsatzTabelle = umsatzTabelle.size();
1133 
1134         GruppeWert gw = null;
1135         int index = -1;
1136 
1137         for (int i = 0; i < groesseUmsatzTabelle; i++)
1138         {
1139             gw = (GruppeWert) umsatzTabelle.get(i);
1140 
1141             umsatzGesamt += gw.getWert().doubleValue();
1142 
1143             if (gw.getGruppennummer().compareTo(gruppennummer) == 0)
1144             {
1145                 index = i;
1146             }
1147         }
1148 
1149         gw = (GruppeWert) umsatzTabelle.get(index);
1150 
1151         if (groesseUmsatzTabelle == 1)
1152         {
1153             ergebnis = Konstanten.HUNDRED_PERCENT;
1154         }
1155         else if (umsatzGesamt > 0)
1156         {
1157             ergebnis = ((gw.getWert().doubleValue() / umsatzGesamt) * Konstanten.HUNDRED_PERCENT);
1158         }
1159         else
1160         {
1161             ergebnis = ((gw.getWert().doubleValue()) * Konstanten.HUNDRED_PERCENT);
1162         }
1163 
1164         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1165         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1166 
1167         return rueckgabewert;
1168     }
1169 
1170     /***
1171      * Liefert den Umsatz des Unternehmens zur&uuml;ck
1172      * Tabelle 21 Zeile 11
1173      *
1174      * @param	absatzTatsaechlich	Der tats&auml;chliche Absatz des Unternehmens
1175      * @param	nominellerPreis Der nominelle Verkaufspresi des Unternehmens
1176      * @return	Der Umsatz des Unternehmens
1177      */
1178     public static final double umsatz(final double absatzTatsaechlich, final double nominellerPreis)
1179     {
1180         double ergebnis = (absatzTatsaechlich * nominellerPreis);
1181 
1182         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1183         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1184 
1185         return rueckgabewert;
1186     }
1187 
1188     /***
1189      * Liefert die Marktforschungskosten zur&uuml;ck
1190      * Tabelle 21 Zeile 16
1191      *
1192      * @param   marktforschungTabelle   Die ArrayList mit den Marktforschungsstufen - Kosten Beziehungen der Unternehmen
1193      * @param   stufeNummer Die gew&auml;hlte Marktforschungsstufe
1194      * @return  Die Marktforschungskosten
1195      */
1196     public static final double marktforschungskosten(final ArrayList marktforschungTabelle, final int stufeNummer)
1197     {
1198         double ergebnis = 0.0;
1199 
1200         int groesseMarktforschungTabelle = marktforschungTabelle.size();
1201 
1202         for (int i = 0; i < groesseMarktforschungTabelle; i++)
1203         {
1204             if (((Marktforschung) marktforschungTabelle.get(i)).getStufe() == stufeNummer)
1205             {
1206                 ergebnis = (((Marktforschung) marktforschungTabelle.get(i)).getKosten());
1207             }
1208         }
1209 
1210         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1211         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1212 
1213         return rueckgabewert;
1214     }
1215 
1216     /***
1217      * Liefert das gesamte Defizit des Projektes zur&uuml;ck
1218      *
1219      * @param   defizitTabelle   Die ArrayList mit den Defiziten der Unternehmen
1220      * @param   gruppennummer Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Korrekturfaktor ausgerechnet werden soll
1221      * @return  Das Gesamtdefizit
1222      */
1223     public static final double gesamtdefizit(final ArrayList defizitTabelle, final Integer gruppennummer)
1224     {
1225         double ergebnis = 0.0;
1226 
1227         int groesseDefizitTabelle = defizitTabelle.size();
1228 
1229         GruppeWert gw = null;
1230 
1231         for (int i = 0; i < groesseDefizitTabelle; i++)
1232         {
1233             gw = (GruppeWert) defizitTabelle.get(i);
1234 
1235             if (gw.getGruppennummer().compareTo(gruppennummer) != 0)
1236             {
1237                 ergebnis += gw.getWert().doubleValue();
1238             }
1239         }
1240 
1241         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1242         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1243 
1244         return rueckgabewert;
1245     }
1246 
1247     /***
1248      * Liefert den Korrekturfaktor zur&uuml;ck
1249      * Tabelle 21 Zeile 16
1250      *
1251      * @param	wirksamerPreisTabelle	Die ArrayList mit den wirksamen Preisen der Unternehmen
1252      * @param   gruppennummer Die Gruppennummer des Unternehmens im ArrayList Table f&uuml;r das der Korrekturfaktor ausgerechnet werden soll
1253      * @return	Der Korrekturfaktor
1254      */
1255     public static final double korrekturfaktor(final ArrayList wirksamerPreisTabelle, final Integer gruppennummer)
1256     {
1257         double ergebnis = 0.0;
1258 
1259         double durchschnitt = 0.0;
1260         double quotient = 0.0;
1261 
1262         int groesseWirksamerPreisTabelle = wirksamerPreisTabelle.size();
1263         int index = -1;
1264 
1265         GruppeWert gw = null;
1266 
1267         for (int i = 0; i < groesseWirksamerPreisTabelle; i++)
1268         {
1269             gw = (GruppeWert) wirksamerPreisTabelle.get(i);
1270 
1271             durchschnitt += gw.getWert().doubleValue();
1272 
1273             if (gw.getGruppennummer().compareTo(gruppennummer) == 0)
1274             {
1275                 index = i;
1276             }
1277         }
1278 
1279         durchschnitt /= groesseWirksamerPreisTabelle;
1280 
1281         gw = (GruppeWert) wirksamerPreisTabelle.get(index);
1282 
1283         if (gw.getWert().doubleValue() <= durchschnitt)
1284         {
1285             ergebnis = 1.0;
1286         }
1287         else
1288         {
1289             quotient = (durchschnitt / gw.getWert().doubleValue());
1290             ergebnis = (quotient *= quotient);
1291         }
1292 
1293         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1294         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1295 
1296         return rueckgabewert;
1297     }
1298 
1299     /***
1300      * Liefert den Sch&auml;tzfehler bei der Qualit&auml;tssicherung zur&uuml;ck
1301      * Sch&auml;tzfehler Qualit&uuml;tssicherung Bewertung
1302      *
1303      * @param	qualitaetssicherungNormal	Der normale Qualit&auml;tssicherungsaufwand
1304      * @param	qualitaetssicherungOptimal	Der optimale Qualit&auml;tssicherungsaufwand
1305      * @param	guteProduktionsmenge	Die gute Produktionsmenge
1306      * @return	Der Sch&auml;tzfehler bei der Qualit&auml;tssicherung
1307      */
1308     public static final double schaetzfehlerQualitaetssicherung(final double qualitaetssicherungNormal, final double qualitaetssicherungOptimal, final double guteProduktionsmenge)
1309     {
1310         double ergebnis = 0.0;
1311 
1312         if (guteProduktionsmenge > 0)
1313         {
1314             ergebnis = ((qualitaetssicherungNormal - qualitaetssicherungOptimal) / guteProduktionsmenge);
1315         }
1316         else
1317         {
1318             ergebnis = ((qualitaetssicherungNormal - qualitaetssicherungOptimal));
1319         }
1320 
1321         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1322         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1323 
1324         return rueckgabewert;
1325     }
1326 
1327     /***
1328      * Liefert den ? zur&uuml;ck
1329      *
1330      * @param
1331      * @param
1332      * @return
1333      */
1334     /*
1335         public static final double (double , double )
1336         {
1337             double ergebnis = ;
1338 
1339             // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1340             double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1341 
1342             return rueckgabewert;
1343         }
1344     */
1345 }