Finanzierung 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.ForschungUndEntwicklung;
25  import org.fhw.cabaweb.data.dataobjects.ProduktartAbhaengigkeiten;
26  import org.fhw.cabaweb.data.dataobjects.Verwaltungskosten;
27  
28  /***
29   * Klasse mit den Berechnungsfunktionen f&uuml;r die Finanzierung
30   *
31   * @author	<a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
32   * @version	Version 1.0 11.-22.03.2004
33   */
34  public final class Finanzierung
35  {
36      /***
37       * Standardkonstruktor der nicht zug&auml;nglich sein soll, da dies eine Utility Klasse ist
38       */
39      protected Finanzierung()
40      {
41          throw new UnsupportedOperationException(); // Aufrufe aus eventuellen SubKlassen verhindern
42      }
43  
44      /***
45       * Interface mit den ben&ouml;tigten Konstanten
46       */
47      interface Konstanten
48      {
49          /***
50           * Zahl die Hundert Prozent repr&auml;sentiert (100.0)
51           */
52          public static final double HUNDRED_PERCENT = 100.0;
53          /***
54           * Eine Million (1000000.0)
55           */
56          public static final double ONE_MILLION = 1000000.0;
57      }
58  
59      /***
60       * Liefert die reale Forschungs- und Entwicklungsausgaben zur&uuml;ck
61       *
62       * @param	nominelleForschungUndEntwicklung	Die nominalen Forschungs- und Entwicklungsaufwendungen
63       * @param	inflationsIndex	Der Infaltionsindex
64       * @return	Die reale Forschungs- und Entwicklungsausgaben
65       */
66      public static final double realeForschungUndEntwicklung(final double nominelleForschungUndEntwicklung, final double inflationsIndex)
67      {
68          double ergebnis = (nominelleForschungUndEntwicklung / inflationsIndex);
69  
70          // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
71          double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
72  
73          return rueckgabewert;
74      }
75  
76      /***
77       * Liefert die wirksamen Forschungs- und Entwicklungsausgaben zur&uuml;ck
78       *
79       * @param	nachhall	Der Nachhall
80       * @param	realeForschungUndEntwicklungVorquartal	Die realen Forschungs- und Entwicklungsaufwendungen im Vorquartal
81       * @param	realeForschungUndEntwicklung	Die realen Forschungs- und Entwicklungsaufwendungen
82       * @return	Die wirksamen Forschungs- und Entwicklungsausgaben
83       */
84      public static final double wirksameForschungUndEntwicklung(final double nachhall, final double realeForschungUndEntwicklungVorquartal, final double realeForschungUndEntwicklung)
85      {
86          double ergebnis = ((realeForschungUndEntwicklung * (1.0 - nachhall)) + (realeForschungUndEntwicklungVorquartal * nachhall));
87  
88          // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
89          double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
90  
91          return rueckgabewert;
92      }
93  
94      /***
95       * Liefert den Pr&auml;ferenzEffekt zur&uuml;ck
96       *
97       * @param	produktArtAbhaengigkeitenTabelle	Die Array List Tabelle mit den Zuordnungen Produktart - Produktarteffekt - Fertigungszeit - Rohstoffverbrauch kapselt
98       * @param	produktArt	Die produzierte Produktart
99       * @return	Der Pr&auml;ferenzEffekt
100      */
101     public static final double praeferenzEffekt(final ArrayList produktArtAbhaengigkeitenTabelle, final int produktArt)
102     {
103         double ergebnis = 0.0;
104 
105         int groesseProduktArtAbhaengigkeitenTabelle = produktArtAbhaengigkeitenTabelle.size();
106 
107         for (int i = 0; i < groesseProduktArtAbhaengigkeitenTabelle; i++)
108         {
109             if (((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getProduktart() == produktArt)
110             {
111                 ergebnis = (((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getProduktarteffekt() / Konstanten.HUNDRED_PERCENT);
112             }
113         }
114 
115         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
116         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
117 
118         return rueckgabewert;
119     }
120 
121     /***
122      * Liefert die nominelle Fertigungsst&uuml;ckzeit zur&uuml;ck
123      *
124      * @param	produktArtAbhaengigkeitenTabelle	Die Array List Tabelle mit den Zuordnungen Produktart - Produktarteffekt - Fertigungszeit - Rohstoffverbrauch kapselt
125      * @param	produktArt	Die produzierte Produktart
126      * @return	Die nominelle Fertigungsst&uuml;ckzeit
127      */
128     public static final double nominelleFertigunsstueckZeit(final ArrayList produktArtAbhaengigkeitenTabelle, final int produktArt)
129     {
130         double ergebnis = 0.0;
131 
132         int groesseProduktArtAbhaengigkeitenTabelle = produktArtAbhaengigkeitenTabelle.size();
133 
134         for (int i = 0; i < groesseProduktArtAbhaengigkeitenTabelle; i++)
135         {
136             if (((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getProduktart() == produktArt)
137             {
138                 ergebnis = ((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getFertigungszeit();
139             }
140         }
141 
142         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
143         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
144 
145         return rueckgabewert;
146     }
147 
148     /***
149      * Liefert den Rohstoffverbrauch pro St&uuml;ck zur&uuml;ck
150      *
151      * @param	produktArtAbhaengigkeitenTabelle	Die Array List Tabelle mit den Zuordnungen Produktart - Produktarteffekt - Fertigungszeit - Rohstoffverbrauch kapselt
152      * @param	produktArt	Die produzierte Produktart
153      * @return	Der Rohstoffverbrauch pro St&uuml;ck
154      */
155     public static final double rohstoffVerbrauchProStueck(final ArrayList produktArtAbhaengigkeitenTabelle, final int produktArt)
156     {
157         double ergebnis = 0.0;
158 
159         int groesseProduktArtAbhaengigkeitenTabelle = produktArtAbhaengigkeitenTabelle.size();
160 
161         for (int i = 0; i < groesseProduktArtAbhaengigkeitenTabelle; i++)
162         {
163             if (((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getProduktart() == produktArt)
164             {
165                 ergebnis = ((ProduktartAbhaengigkeiten) produktArtAbhaengigkeitenTabelle.get(i)).getRohstoffverbrauch();
166             }
167         }
168 
169         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
170         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
171 
172         return rueckgabewert;
173     }
174 
175     /***
176      * Liefert die durch die Forschung und Entwicklung im n&auml;chten Quartal m&ouml;gliche Produktart zur&uuml;ck
177      *
178      * @param	fueWirk	Die wirksamen Forschungs- und Entwicklungsaufwendungen
179      * @param	forschungUndEntwicklungTabelle	Arra<List Tabelle mit den Assoziationen wirksame FundE - Produktart&auml;nderung
180      * @param	produktArt	Die momentan m&oumlgliche Produktart
181      * @param	maximaleProduktArt	Die maximal m&oumlgliche Produktart
182      * @return	Die m&oumlgliche Prodktart im n&auml;chsten Quartal
183      */
184     public static final int produktArt(final double fueWirk, final ArrayList forschungUndEntwicklungTabelle, final int produktArt, final int maximaleProduktArt)
185     {
186         int rueckgabewert = 0;
187 
188         int groesseForschungUndEntwicklungTabelle = forschungUndEntwicklungTabelle.size();
189 
190         // suche die entsprechende Stufe
191         if (fueWirk <= ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(0)).getForschungUndEntwicklungWirksam() && produktArt == 1)
192         {
193             rueckgabewert = produktArt + ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(0)).getProduktartaenderung();
194         }
195         else if (fueWirk > ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(groesseForschungUndEntwicklungTabelle - 1)).getForschungUndEntwicklungWirksam())
196         {
197             rueckgabewert = produktArt + ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(groesseForschungUndEntwicklungTabelle - 1)).getProduktartaenderung();
198         }
199         else
200         {
201             for (int i = 0; i < groesseForschungUndEntwicklungTabelle - 1; i++)
202             {
203                 if (fueWirk >= ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(i)).getForschungUndEntwicklungWirksam() && fueWirk < ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(i + 1)).getForschungUndEntwicklungWirksam())
204                 {
205                     rueckgabewert = produktArt + ((ForschungUndEntwicklung) forschungUndEntwicklungTabelle.get(i)).getProduktartaenderung();
206                 }
207             }
208         }
209 
210         if (rueckgabewert < 1)
211             rueckgabewert = 1;
212         if (rueckgabewert > maximaleProduktArt)
213             rueckgabewert = maximaleProduktArt;
214 
215         return rueckgabewert;
216     }
217 
218     /***
219      * Liefert den durchschnittlichen Zinssatz zur&uuml;ck
220      * Tabelle 23 (41)
221      *
222      * @param	bankdarlehenZinssatz	Der Zinssatz des &Uuml;berziehungskredits
223      * @param	kontokorrentkreditZinssatz	Der Zinssatz des &Uuml;berziehungskredits
224      * @param	kontokorrentkredit	Die H&oumlhe des &Uuml;berziehungskredit
225      * @param	bankdarlehen	Die H&oumlhe des Bankdarlehens
226      * @return	Der durchschnittliche Zinssatz
227      */
228     public static final double durchschnittlicherZinssatz(final double bankdarlehenZinssatz, final double kontokorrentkreditZinssatz, final double kontokorrentkredit, final double bankdarlehen)
229     {
230         double bankdarlehenZinssatzTemp = bankdarlehenZinssatz / Konstanten.HUNDRED_PERCENT;
231         double kontokorrentkreditZinssatzTemp = kontokorrentkreditZinssatz / Konstanten.HUNDRED_PERCENT;
232 
233         double ergebnis = 0.0;
234 
235         double temp = (kontokorrentkredit + bankdarlehen);
236 
237         if (temp > 0)
238         {
239             temp = (Konstanten.HUNDRED_PERCENT / (kontokorrentkredit + bankdarlehen));
240             ergebnis = ((kontokorrentkreditZinssatzTemp * temp * kontokorrentkredit) + (bankdarlehenZinssatzTemp * temp * bankdarlehen));
241         }
242         else
243         {
244             ergebnis = ((kontokorrentkreditZinssatzTemp * kontokorrentkredit) + (bankdarlehenZinssatzTemp * bankdarlehen));
245         }
246 
247         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
248         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
249 
250         return rueckgabewert;
251     }
252 
253     /***
254      * Liefert den Zinssatz f&uml;r den &Uuml;berziehungskredit zur&uuml;ck
255      *
256      * @param	nettoDividendeVorquartal	Die Nettodividende im Vorquartal
257      * @param	ueberziehungsKredit	Die H&ouml;he des &Uuml;berziehungskredits
258      * @param	kontokorrentKreditBasisZinssatz	Der Basiszinssatz f&uuml;r den Kontokorrentkredit
259      * @return	Den Zinssatz f&uml;r den &Uuml;berziehungskredit
260      */
261     public static final double zinssatzUeberziehungsKredit(final double nettoDividendeVorquartal, final double ueberziehungsKredit, final double kontokorrentKreditBasisZinssatz)
262     {
263         double ergebnis = 0.0;
264 
265         double exponent1 = Math.exp(- (nettoDividendeVorquartal / 1000000.0) / 0.2);
266         double exponent2 = Math.exp(- (ueberziehungsKredit / 1000000.0) / 6.0);
267 
268         ergebnis = ((exponent1 + 1.0 - exponent2) * kontokorrentKreditBasisZinssatz);
269 
270         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
271         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
272 
273         return rueckgabewert;
274     }
275 
276     /***
277      * Liefert den Grenzzinssatz f&uml;r den &Uuml;berziehungskredit zur&uuml;ck
278      *
279      * @param	nettoDividendeVorquartal	Die Nettodividende im Vorquartal
280      * @param	ueberziehungsKredit	Die H&ouml;he des &Uuml;berziehungskredits
281      * @param	kontokorrentKreditBasisZinssatz	Der Basiszinssatz f&uuml;r den Kontokorrentkredit
282      * @return	Den Grenzzinssatz f&uml;r den &Uuml;berziehungskredit
283      */
284     public static final double grenzZinssatzUeberziehungskredit(final double nettoDividendeVorquartal, final double ueberziehungsKredit, final double kontokorrentKreditBasisZinssatz)
285     {
286         double ergebnis = 0.0;
287 
288         double exponent1 = (- (nettoDividendeVorquartal / Konstanten.ONE_MILLION) / 0.2);
289         double exponent2 = (- (ueberziehungsKredit / Konstanten.ONE_MILLION) / 6.0);
290         double exponent3 = (- ((ueberziehungsKredit / Konstanten.ONE_MILLION) + 0.001) / 6.0);
291 
292         ergebnis = ((Math.exp(exponent1) + 1.0 - Math.exp(exponent3)) * kontokorrentKreditBasisZinssatz * ((ueberziehungsKredit / Konstanten.ONE_MILLION) + 0.001) - (Math.exp(exponent1) + 1.0 - Math.exp(exponent2)) * kontokorrentKreditBasisZinssatz * (ueberziehungsKredit / Konstanten.ONE_MILLION)) / 0.001;
293 
294         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
295         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
296 
297         return rueckgabewert;
298     }
299 
300     /***
301      * Liefert die Zinskosten f&uuml;r den &Uuml;berziehungskredit zur&uuml;ck
302      *
303      * @param	ueberziehungsKredit	Die H&ouml;he des &Uuml;berziehungskredits
304      * @param	zinsenUeberziehungsKredit	Der Zinssatz &Uuml;berziehungskredits
305      * @return	Die Zinskosten f&uuml;r den &Uuml;berziehungskredit
306      */
307     public static final double zinskostenUeberziehungskredit(final double ueberziehungsKredit, final double zinsenUeberziehungsKredit)
308     {
309         double ergebnis = (ueberziehungsKredit * zinsenUeberziehungsKredit);
310 
311         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
312         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
313 
314         return rueckgabewert;
315     }
316 
317     /***
318      * Liefert die Zinskosten f&uuml;r den Bankkredit zur&uuml;ck
319      *
320      * @param	kredit	Die H&ouml;he des Bankkredits
321      * @param	zinssatzKreditVereinbart	Der Zinssatz Bankkredits
322      * @return	Die Zinskosten f&uuml;r den Bankkredit
323      */
324     public static final double zinskostenBankkredit(final double kredit, final double zinssatzKreditVereinbart)
325     {
326         double ergebnis = (kredit * zinssatzKreditVereinbart);
327 
328         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
329         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
330 
331         return rueckgabewert;
332     }
333 
334     /***
335      * Liefert die zuviel bezahlten Zinsen zur&uuml;ck
336      * Tabelle 23 (42)
337      *
338      * @param	nettoDividendeVorquartal	Die H&ouml;he der ausgesch&uuml;tteten Netto Dividende im Vorquartal
339      * @param	basisZinsSatzBankdarlehen	Der Basiszinssatz f&uuml;r das Bankdarlehen
340      * @param	kontokorrentkreditVorquartal	Die H&ouml;he des Kontokorrentkredits im Vorquartal
341      * @param	bankkreditVorquartal	Die H&ouml;he des Bankkredits im Vorquartal
342      * @param	kontokorrentkreditAenderungOptimal	Die optimale &Auml;nderung des Kontokorrentkredits
343      * @param	bankkreditAenderungOptimal	Die optimale &Auml;nderung des Bankkredits
344      * @param	zinskosten	Die vom Unternehmen veranschlagten Zinskosten
345      * @return	Die zuviel bezahlten Zinsen
346      */
347     public static final double zinsenZuviel(final double nettoDividendeVorquartal, final double basisZinsSatzBankdarlehen, final double kontokorrentkreditVorquartal, double bankkreditVorquartal, final double kontokorrentkreditAenderungOptimal, final double bankkreditAenderungOptimal, final double zinskosten)
348     {
349         double ergebnis = 0.0;
350 
351         double kontokorrentkredit, bankkredit, zinsen, temp;
352 
353         kontokorrentkredit = kontokorrentkreditVorquartal + kontokorrentkreditAenderungOptimal;
354         bankkredit = bankkreditVorquartal + bankkreditAenderungOptimal;
355 
356         temp = zinssatzUeberziehungsKredit(nettoDividendeVorquartal, kontokorrentkredit, basisZinsSatzBankdarlehen) / Konstanten.HUNDRED_PERCENT;
357         zinsen = (bankkredit * (basisZinsSatzBankdarlehen / Konstanten.HUNDRED_PERCENT)) + (kontokorrentkredit * temp);
358 
359         ergebnis = (zinskosten - zinsen);
360 
361         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
362         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
363 
364         return rueckgabewert;
365     }
366 
367     /***
368      * Liefert die optimale H&ouml;he des Kontokorrentkredits zur&uuml;ck
369      *
370      * @param	nettoDividende	Die H&ouml;he der ausgesch&uuml;tteten Netto Dividende
371      * @param	basisZinsSatzBankdarlehen	Der Basiszinssatz f&uuml;r das Bankdarlehen
372      * @return	Die optimale H&ouml;he des Kontokorrentkredits
373      */
374     public static final double ueberziehungsKreditOptimal(final double nettoDividende, final double basisZinsSatzBankdarlehen)
375     {
376         double ergebnis = 0.0;
377 
378         double ueberziehungsKredit = 0.0;
379 
380         while (grenzZinssatzUeberziehungskredit(nettoDividende, ueberziehungsKredit, basisZinsSatzBankdarlehen) < basisZinsSatzBankdarlehen)
381         {
382             ueberziehungsKredit += 1000;
383         }
384 
385         ergebnis = ueberziehungsKredit;
386 
387         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
388         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
389 
390         return rueckgabewert;
391     }
392 
393     /***
394      * Liefert die optimale &Auml;nderung der H&ouml;he des Kontokorrentkredits zur&uuml;ck
395      *
396      * @param	ueberziehungsKreditOptimal	Die optimale &Auml;nderung der H&ouml;he des Kontokorrentkredits
397      * @param	ueberziehungsKreditVorquartal	Die H&ouml;he des Kontokorrentkredits im Vorquartal
398      * @return	Die optimale &Auml;nderung der H&ouml;he des Kontokorrentkredits
399      */
400     public static final double ueberziehungsKreditAenderungOptimal(final double ueberziehungsKreditOptimal, final double ueberziehungsKreditVorquartal)
401     {
402         double ergebnis = (ueberziehungsKreditOptimal - ueberziehungsKreditVorquartal);
403 
404         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
405         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
406 
407         return rueckgabewert;
408     }
409 
410     /***
411      * Liefert die optimale &Auml;nderung der H&ouml;he des vereinbarten Kredits zur&uuml;ck
412      *
413      * @param	kapitalbedarf	Der Kapotialbedarf f&uuml;r dieses Quartal
414      * @param	ueberziehungsKreditAenderungOptimal	Die optimale &Auml;nderung der H&ouml;he des Kontokorrentkredits
415      * @return	Die optimale &Auml;nderung der H&ouml;he des vereinbarten Kredits
416      */
417     public static final double vereinbarterKreditAenderungOptimal(final double kapitalbedarf, final double ueberziehungsKreditAenderungOptimal)
418     {
419         double ergebnis = (kapitalbedarf - ueberziehungsKreditAenderungOptimal);
420 
421         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
422         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
423 
424         return rueckgabewert;
425     }
426 
427     /***
428      * Liefert den Brutto Dividende zur&uuml;ck
429      *
430      * @deprecated
431         * @param	dividende	Die vom Unternehmen gew&uuml;nschte Dividende
432      * @param	erfolgVorSteuern	Der Erfolg vor Steuern
433      * @return	Die Brutto Dividende
434      */
435     public static final double bruttoDividende(final double dividende, final double erfolgVorSteuern)
436     {
437         double ergebnis = (erfolgVorSteuern * dividende);
438 
439         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
440         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
441 
442         return rueckgabewert;
443     }
444 
445     /***
446      * Liefert den Steuern auf die Brutto Dividende zur&uuml;ck
447      *
448      * @deprecated
449      * @param	koerperschaftssteuer_ausgeschuettete_Gewinne	Die K&ouml;rperschaftssteuer auf ausgesch&uuml;ttete Gewinne
450      * @param	bruttoDividende	Die Brutto Dividende
451      * @return	Die Steuern auf die Brutto Dividende
452      */
453     public static final double steuernAufBruttoDividende(final double koerperschaftssteuer_ausgeschuettete_Gewinne, final double bruttoDividende)
454     {
455         double ergebnis = (bruttoDividende * koerperschaftssteuer_ausgeschuettete_Gewinne);
456 
457         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
458         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
459 
460         return rueckgabewert;
461     }
462 
463     /***
464      * Liefert die Netto Dividende zur&uuml;ck
465      *
466      * @deprecated
467      * @param	bruttoDividende	Die Brutto Dividende
468      * @param	steuernAufBruttoDividende	Die Steuern auf die Brutto Dividende
469      * @return	Die Netto Dividende
470      */
471     public static final double nettoDividende(final double bruttoDividende, final double steuernAufBruttoDividende)
472     {
473         double ergebnis = (bruttoDividende - steuernAufBruttoDividende);
474 
475         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
476         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
477 
478         return rueckgabewert;
479     }
480 
481     /***
482      * Liefert den Restbetrag vor Steuern zur&uuml;ck
483      *
484      * @deprecated
485      * @param	erfolgVorSteuern	Der Erfolg vor Steuern
486      * @param	bruttoDividende	Die Brutto Dividende
487      * @return	Der Restbetrag vor Steuern
488      */
489     public static final double restbetragVorSteuern(final double erfolgVorSteuern, final double bruttoDividende)
490     {
491         double ergebnis = (erfolgVorSteuern - bruttoDividende);
492 
493         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
494         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
495 
496         return rueckgabewert;
497     }
498 
499     /***
500      * Liefert die Steuern auf den Restbetrag zur&uuml;ck
501      *
502      * @deprecated
503      * @param	koerperschaftssteuer_einbehaltene_Gewinne	Die K&ouml;rperschaftssteuer auf einbehaltene Gewinne
504      * @param	restbetragVorSteuern	Der Restbetrag vor Steuern
505      * @return	Die Steuern auf den Restbetrag
506      */
507     public static final double steuernAufRestbetrag(final double koerperschaftssteuer_einbehaltene_Gewinne, final double restbetragVorSteuern)
508     {
509         double ergebnis = (restbetragVorSteuern * koerperschaftssteuer_einbehaltene_Gewinne);
510 
511         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
512         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
513 
514         return rueckgabewert;
515     }
516 
517     /***
518      * Liefert die R&uuml;cklagenzuf&uuml;hrung zur&uuml;ck
519      *
520      * @deprecated
521      * @param	steuernAufRestbetrag	Die Steuern auf den Restbetrag
522      * @param	restbetragVorSteuern	Der Restbetrag vor Steuern
523      * @return	Die R&uuml;cklagenzuf&uuml;hrung
524      */
525     public static final double ruecklagenzufuehrung(final double steuernAufRestbetrag, final double restbetragVorSteuern)
526     {
527         double ergebnis = (restbetragVorSteuern - steuernAufRestbetrag);
528 
529         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
530         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
531 
532         return rueckgabewert;
533     }
534 
535     /***
536      * Liefert das Anlageverm&ouml;gen zur&uuml;ck
537      *
538      * @param	anlageVermoegenVorquartal	Die H&ouml;he des Anlageverm&ouml;gens im Vorquartal
539      * @param	abschreibungKosten	Die Abschreibungskosten
540      * @param	investition	Die H&ouml;he der Investitionen
541      * @return	Das Anlageverm&ouml;gen
542      */
543     public static final double anlageVermoegen(final double anlageVermoegenVorquartal, final double abschreibungKosten, final double investition)
544     {
545         double ergebnis = (anlageVermoegenVorquartal + abschreibungKosten + investition);
546 
547         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
548         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
549 
550         return rueckgabewert;
551     }
552 
553     /***
554      * Liefert den in der Kasse befindlichen Betrag zur&uuml;ck
555      *
556      * @param	kasseVorquartal	Der im Vorquartal in der Kasse befindliche Betrag
557      * @param	kapitalerhoehungVorquartal	Die Kapitalerh&ouml;hung im Vorquartal
558      * @param	unverzinslicheVerbindlichkeitenVorquartal	Die unverzinslichen Verbindlichkeiten im Vorquartal
559      * @param	liquiditaetsWirksamerErfolgOhneZinsen	Der liquidit&auml;tswirksame Erfolg im Vorquartal
560      * @param	aenderungBankkredit	Die &Auml;nderung des Bankkredits
561      * @param	aenderungKontokorrentkredit	Die &Auml;nderung des Kontokorrentkredits
562      * @return	Der in der Kasse befindliche Betrag
563      */
564     public static final double kasse(final double kasseVorquartal, final double kapitalerhoehungVorquartal, final double unverzinslicheVerbindlichkeitenVorquartal, final double liquiditaetsWirksamerErfolgOhneZinsen, final double aenderungBankkredit, final double aenderungKontokorrentkredit)
565     {
566         double ergebnis = (kasseVorquartal + kapitalerhoehungVorquartal - unverzinslicheVerbindlichkeitenVorquartal + liquiditaetsWirksamerErfolgOhneZinsen + aenderungBankkredit + aenderungKontokorrentkredit);
567 
568         if (ergebnis <= 0)
569             ergebnis = 0.0;
570 
571         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
572         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
573 
574         return rueckgabewert;
575     }
576 
577     /***
578      * Liefert die Kapitalerh&ouml;hung zur&uuml;ck
579      *
580      * @param	nettoDividende	Die Netto Dividende
581      * @param	nettoDividendeVorquartal	Die Netto Dividende im Vorquartal
582      * @return	Die Kapitalerh&ouml;hung
583      */
584     public static final double kapitalerhoehung(final double nettoDividende, final double nettoDividendeVorquartal)
585     {
586         double ergebnis = (2.0 * Math.min(nettoDividende, nettoDividendeVorquartal));
587 
588         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
589         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
590 
591         return rueckgabewert;
592     }
593 
594     /***
595      * Liefert die Aktiva zur&uuml;ck
596      *
597      * @param	anlageVermoegen	Das Anlageverm&ouml;gen
598      * @param	rohstoffLagerBestandEuro	Der Wert des Rohstofflagerbestands
599      * @param	lagerBestandFertigprodukteEuro	Der Wert des Fertigproduktlagerbestands
600      * @param	kasse	Der in der Kasse befindliche Betrag
601      * @param	kapitalerhoehung	Die H&ouml;he der Kapitalerh&ouml;hung
602      * @return	Die Aktiva
603      */
604     public static final double aktiva(final double anlageVermoegen, final double rohstoffLagerBestandEuro, final double lagerBestandFertigprodukteEuro, final double kasse, final double kapitalerhoehung)
605     {
606         double ergebnis = (anlageVermoegen + rohstoffLagerBestandEuro + lagerBestandFertigprodukteEuro + kasse + kapitalerhoehung);
607 
608         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
609         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
610 
611         return rueckgabewert;
612     }
613 
614     /***
615      * Liefert die Passiva zur&uuml;ck
616      *
617      * @param	eigenKapital	Die H&ouml;he des Eigenkapitals
618      * @param	unverzinslicheVerbindlichkeiten	Die H&ouml;he der unverzinslichen Verbindlichkeiten
619      * @param	ueberziehungsKredit	Die H&ouml;he des &Uuml;berziehungskredits
620      * @param	vereinbartKredit	Die H&ouml;he des vereinbarten Kredits
621      * @return	Die Passiva
622      */
623     public static final double passiva(final double eigenKapital, final double unverzinslicheVerbindlichkeiten, final double ueberziehungsKredit, final double vereinbartKredit)
624     {
625         double ergebnis = (eigenKapital + unverzinslicheVerbindlichkeiten + ueberziehungsKredit + vereinbartKredit);
626 
627         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
628         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
629 
630         return rueckgabewert;
631     }
632 
633     /***
634      * Liefert das Eigenkapital zur&uuml;ck
635      *
636      * @param	aktiva	Die Aktiva
637      * @param	unverzinslicheVerbindlichkeiten	Die H&ouml;he der unverzinslichen Verbindlichkeiten
638      * @param	ueberziehungsKredit	Die H&ouml;he des vereinbarten Kredits
639      * @param	vereinbartKredit	Die H&ouml;he des vereinbarten Kredits
640      * @return	Das Eigenkapital
641      */
642     public static final double eigenKapital(final double aktiva, final double unverzinslicheVerbindlichkeiten, final double ueberziehungsKredit, final double vereinbartKredit)
643     {
644         double ergebnis = (aktiva - (unverzinslicheVerbindlichkeiten + ueberziehungsKredit + vereinbartKredit));
645 
646         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
647         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
648 
649         return rueckgabewert;
650     }
651 
652     /***
653      * Liefert die unverzinslichen Verbindlichkeiten zur&uuml;ck
654      *
655      * @param	rohstoffeEingekauft	Kosten des Rohstoffeinkaufs (normal + express)
656      * @param	investition	Die Investitionen
657      * @param	nettoDividende	Die Netto Dividende
658      * @param	steuernGesamt	Die gesamten Steuern
659      * @param	zinsenUeberziehungskreditEuro	Die Zinskosten f&uuml;r den &Uuml;berziehungskredit
660      * @param	zinsenKreditEuro	Die Zinskosten f&uuml;r den Bankkredit
661      * @return	Die unverzinslichen Verbindlichkeiten
662      */
663     public static final double unverzinslicheVerbindlichkeiten(final double rohstoffeEingekauft, final double investition, final double nettoDividende, final double steuernGesamt, final double zinsenUeberziehungskreditEuro, final double zinsenKreditEuro)
664     {
665         double ergebnis = (rohstoffeEingekauft + investition + nettoDividende + steuernGesamt + zinsenUeberziehungskreditEuro + zinsenKreditEuro);
666 
667         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
668         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
669 
670         return rueckgabewert;
671     }
672 
673     /***
674      * Liefert die H&ouml;he des &Uuml;berziehungskredits zur&uuml;ck
675      * Tabelle 22 Zeile 23
676      *
677      * @param	ueberziehungsKreditAenderungOptimal	Die optimale &Auml;nderung des Kontokorrentkredits
678      * @param	ueberziehungsKreditVorquartal	Die &Auml;nderung des Kontokorrentkredits im Vorquartal
679      * @param	vereinbarterKreditAenderung	Die &Auml;nderung des vereinbarten Kredits
680      * @param	vereinbarterKreditAenderungOptimal	Die optimale &Auml;nderung des vereinbarten Kredits
681      * @param	vereinbarterKreditVorquartal	Die &Auml;nderung des vereinbarten Kredits im Vorquartal
682      * @param	kasse	Der in der Kasse befindliche Betrag
683      * @return	Die H&ouml;he des &Uuml;berziehungskredits
684      */
685     public static final double ueberziehungsKredit(final double ueberziehungsKreditAenderungOptimal, final double ueberziehungsKreditVorquartal, final double vereinbarterKreditAenderung, final double vereinbarterKreditAenderungOptimal, final double vereinbarterKreditVorquartal, final double kasse)
686     {
687         double ergebnis = 0.0;
688 
689         if ((vereinbarterKreditVorquartal + vereinbarterKreditAenderung) > 0)
690             ergebnis = (ueberziehungsKreditVorquartal + ueberziehungsKreditAenderungOptimal + (vereinbarterKreditAenderungOptimal - vereinbarterKreditAenderung) - kasse);
691         else
692             ergebnis = (ueberziehungsKreditVorquartal + ueberziehungsKreditAenderungOptimal + (vereinbarterKreditAenderungOptimal + vereinbarterKreditVorquartal) - kasse);
693 
694         if (ergebnis <= 0)
695             ergebnis = 0.0;
696 
697         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
698         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
699 
700         return rueckgabewert;
701     }
702 
703     /***
704      * Liefert der vereinbarte Kredit zur&uuml;ck
705      * Die optimale Ver&auml;nderung ist im Entscheidungsblatt vorgegeben
706      *
707      * @param	vereinbarterKreditVorquartal	Die H&ouml;he des vereinbarten Kredits im Vorquartal
708      * @param	vereinbarterKreditAenderung	Die &Auml;nderung des vereinbarten Kredits
709      * @return	Der vereinbarte Kredit
710      */
711     public static final double vereinbartKredit(final double vereinbarterKreditVorquartal, final double vereinbarterKreditAenderung)
712     {
713         double ergebnis = (vereinbarterKreditVorquartal + vereinbarterKreditAenderung);
714 
715         if (ergebnis > 0);
716         else
717             ergebnis = 0.0;
718 
719         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
720         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
721 
722         return rueckgabewert;
723     }
724 
725     /***
726      * Liefert den Erfolg vor Steuern zur&uuml;ck
727      * Tabelle 21 Zeile 51 => Fertigungslohnkostten nach altem CABA
728      * Beachte : Kosten sind negativ
729      *
730      * @param	umsatz 	Der Ums&auml;tze
731      * @param	marketing	Die Marketingkosten
732      * @param	lagerabgang	Die Lagerabgangsgewinne
733      * @param	lagerzugang	Die Lagerzugangskosten
734      * @param	lagerungskosten	Die Lagerungskosten
735      * @param	marktforschung	Die Marktofschugnskosten
736      * @param	fUndE	Die Forschungs- und Entwicklungskosten
737      * @param	lizenzerwerb	Die Lizenzerwerbskosten
738      * @param	lizenzverkauf	Die Lizenzverkaufserl&ouml;se
739      * @param	aufarbeitung 	Die Aufarbeitungskosten
740      * @param	qualitaetssicherung 	Die Qualit&auml;tssicherungsaufwendungen
741      * @param	fertigungslohnkosten 	Die Fertigungslohnkosten
742      * @param	ueberstunden 	Die &Uuml;berstundenlohnkosten
743      * @param	schichtwechsel 	Die Schichtwechselkosten
744      * @param	abschreibung 	Die Abschreibungskosten
745      * @param	anlagenprojektierung	Die anlagenprojektierungskosten
746      * @param	rohstoffverbrauch	Die Rohstoffverbrauchskosten
747      * @param	rohstoffbestellung	Die Rohstoffbestellungskosten
748      * @param	rohstofflagerkosten	Die Rohstofflagerungskosten
749      * @param	verwaltung	Die Verwaltungskosten
750      * @param	beratung	Die Beratungskosten
751      * @param	zinskostenUberziehungskredit	 Die Zinskosten f&uuml;r den &Uuml;berziehungskredit
752      * @param	zinskostenVereinbartKredit	Die Zinskosten f&uuml;r den vereinbarten Kredit
753      * @return	Der Erfolg vor Steuern
754      */
755     public static final double erfolgVorSteuern(
756         final double umsatz,
757         final double marketing,
758         final double lagerabgang,
759         final double lagerzugang,
760         final double lagerungskosten,
761         final double marktforschung,
762         final double fUndE,
763         final double lizenzerwerb,
764         final double lizenzverkauf,
765         final double aufarbeitung,
766         final double qualitaetssicherung,
767         final double fertigungslohnkosten,
768         final double ueberstunden,
769         final double schichtwechsel,
770         final double abschreibung,
771         final double anlagenprojektierung,
772         final double rohstoffverbrauch,
773         final double rohstoffbestellung,
774         final double rohstofflagerkosten,
775         final double verwaltung,
776         final double beratung,
777         final double zinskostenUberziehungskredit,
778         final double zinskostenVereinbartKredit)
779     {
780         double ergebnis =
781             (umsatz
782                 + marketing
783                 + lagerabgang
784                 + lagerzugang
785                 + lagerungskosten
786                 + marktforschung
787                 + fUndE
788                 + lizenzerwerb
789                 + lizenzverkauf
790                 + aufarbeitung
791                 + qualitaetssicherung
792                 + fertigungslohnkosten
793                 + ueberstunden
794                 + schichtwechsel
795                 + abschreibung
796                 + anlagenprojektierung
797                 + rohstoffverbrauch
798                 + rohstoffbestellung
799                 + rohstofflagerkosten
800                 + verwaltung
801                 + beratung
802                 + zinskostenUberziehungskredit
803                 + zinskostenVereinbartKredit);
804 
805         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
806         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
807 
808         return rueckgabewert;
809     }
810 
811     /***
812      * Liefert den liquidit&auml;tswirksamen Erfolg ohne Zinsen zur&uuml;ck
813      * Tabelle 23 Zeile 21
814      * Beachte : Kosten sind negativ
815      *
816      * @param	umsatz 	Der Ums&auml;tze
817      * @param	marketing	Die Marketingkosten
818      * @param	lagerungskosten	Die Lagerungskosten
819      * @param	marktforschung	Die Marktofschugnskosten
820      * @param	fUndE	Die Forschungs- und Entwicklungskosten
821      * @param	lizenzerwerb	Die Lizenzerwerbskosten
822      * @param	lizenzverkauf	Die Lizenzverkaufserl&ouml;se
823      * @param	aufarbeitung 	Die Aufarbeitungskosten
824      * @param	qualitaetssicherung 	Die Qualit&auml;tssicherungsaufwendungen
825      * @param	fertigungslohnkosten 	Die Fertigungslohnkosten
826      * @param	ueberstunden 	Die &Uuml;berstundenlohnkosten
827      * @param	schichtwechsel 	Die Schichtwechselkosten
828      * @param	anlagenprojektierung	Die anlagenprojektierungskosten
829      * @param	rohstoffbestellung	Die Rohstoffbestellungskosten
830      * @param	rohstofflagerkosten	Die Rohstofflagerungskosten
831      * @param	verwaltung	Die Verwaltungskosten
832      * @param	beratung	Die Beratungskosten
833      * @return	Der liquidit&auml;tswirksame Erfolg ohne Zinsen
834      */
835     public static final double liquiditaetswirksamerErfolgOhneZinsen(
836         final double umsatz,
837         final double marketing,
838         final double lagerungskosten,
839         final double marktforschung,
840         final double fUndE,
841         final double lizenzerwerb,
842         final double lizenzverkauf,
843         final double aufarbeitung,
844         final double qualitaetssicherung,
845         final double fertigungslohnkosten,
846         final double ueberstunden,
847         final double schichtwechsel,
848         final double anlagenprojektierung,
849         final double rohstoffbestellung,
850         final double rohstofflagerkosten,
851         final double verwaltung,
852         final double beratung)
853     {
854         double ergebnis = (umsatz + marketing + lagerungskosten + marktforschung + fUndE + lizenzerwerb + lizenzverkauf + aufarbeitung + qualitaetssicherung + fertigungslohnkosten + ueberstunden + schichtwechsel + anlagenprojektierung + rohstoffbestellung + rohstofflagerkosten + verwaltung + beratung);
855 
856         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
857         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
858 
859         return rueckgabewert;
860     }
861 
862     /***
863      * Liefert den zus&auml;tzlichen Kapitalbedarf zur&uuml;ck
864      * Tabelle 23 Zeile 22
865      *
866      * @param	summeEndeVorquartal	Die Summe am Ende des Vorquartals
867      * @param	liquiditaetswirksamerErfolgOhneZinsen	Der liquiditaetswirksame Erfolg ohne Zinsen
868      * @return	Der zus&auml;tzliche Kapitalbedarf
869      */
870     public static final double zusaetzlicherKapitalbedarf(final double summeEndeVorquartal, final double liquiditaetswirksamerErfolgOhneZinsen)
871     {
872         double ergebnis = (summeEndeVorquartal - liquiditaetswirksamerErfolgOhneZinsen);
873 
874         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
875         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
876 
877         return rueckgabewert;
878     }
879 
880     /***
881      * Liefert den liquidit&auml;tswirksamen Erfolg zur&uuml;ck
882      * Tabelle 23 Zeile 55
883      *
884      * @param	umsatz 	Der Ums&auml;tze
885      * @param	marketing	Die Marketingkosten
886      * @param	lagerungskosten	Die Lagerungskosten
887      * @param	marktforschung	Die Marktofschugnskosten
888      * @param	fUndE	Die Forschungs- und Entwicklungskosten
889      * @param	lizenzerwerb	Die Lizenzerwerbskosten
890      * @param	lizenzverkauf	Die Lizenzverkaufserl&ouml;se
891      * @param	aufarbeitung 	Die Aufarbeitungskosten
892      * @param	qualitaetssicherung 	Die Qualit&auml;tssicherungsaufwendungen
893      * @param	fertigungslohnkosten 	Die Fertigungslohnkosten
894      * @param	ueberstunden 	Die &Uuml;berstundenlohnkosten
895      * @param	schichtwechsel 	Die Schichtwechselkosten
896      * @param	anlagenprojektierung	Die anlagenprojektierungskosten
897      * @param	rohstoffbestellung	Die Rohstoffbestellungskosten
898      * @param	rohstofflagerkosten	Die Rohstofflagerungskosten
899      * @param	verwaltung	Die Verwaltungskosten
900      * @param	beratung	Die Beratungskosten
901      * @param	zinskostenUberziehungskredit	 Die Zinskosten f&uuml;r den &Uuml;berziehungskredit
902      * @param	zinskostenVereinbartKredit	Die Zinskosten f&uuml;r den vereinbarten Kredit
903      * @return	Der liquidit&auml;tswirksame Erfolg
904      */
905     public static final double liquiditaetswirksamerErfolg(
906         final double umsatz,
907         final double marketing,
908         final double lagerungskosten,
909         final double marktforschung,
910         final double fUndE,
911         final double lizenzerwerb,
912         final double lizenzverkauf,
913         final double aufarbeitung,
914         final double qualitaetssicherung,
915         final double fertigungslohnkosten,
916         final double ueberstunden,
917         final double schichtwechsel,
918         final double anlagenprojektierung,
919         final double rohstoffbestellung,
920         final double rohstofflagerkosten,
921         final double verwaltung,
922         final double beratung,
923         final double zinskostenUberziehungskredit,
924         final double zinskostenVereinbartKredit)
925     {
926         double ergebnis = (umsatz + marketing + lagerungskosten + marktforschung + fUndE + lizenzerwerb + lizenzverkauf + aufarbeitung + qualitaetssicherung + fertigungslohnkosten + ueberstunden + schichtwechsel + anlagenprojektierung + rohstoffbestellung + rohstofflagerkosten + verwaltung + beratung + zinskostenUberziehungskredit + zinskostenVereinbartKredit);
927 
928         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
929         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
930 
931         return rueckgabewert;
932     }
933 
934     /***
935      * Liefert die Liquidit&auml;ts&auml;nderung zur&uuml;ck
936      * Tabelle 23 Zeile 56
937      * Alle Werte sind negativ oder gleich Null
938      *
939      * @param	investition	Die Investitionen
940      * @param	rohstoffe	Die Rohstoffkosten
941      * @param	nettoDividende	Die Netto Dividende
942      * @param	steuern	Die Steuern
943      * @param	liquiditaetswirksamerErfolg	Der liquidit&auml;tswirksame Erfolg
944      * @return	Die Liquidit&auml;ts&auml;nderung
945      */
946     public static final double liquiditaetsaenderung(final double investition, final double rohstoffe, final double nettoDividende, final double steuern, final double liquiditaetswirksamerErfolg)
947     {
948         double ergebnis = (investition + rohstoffe + nettoDividende + steuern + liquiditaetswirksamerErfolg);
949 
950         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
951         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
952 
953         return rueckgabewert;
954     }
955 
956     //	-------------------------------------------
957     //	Voll - Kostenrechnung
958     //	-------------------------------------------
959     //	Tabelle A.1.1: Planungsbogen zur Vollkostenrechnung
960 
961     /***
962      * Liefert die Vollkosten (Vollkostenrechnung) zur&uuml;ck
963      *
964      * @param	vertriebskosten	Die Vertriebskosten (Vollkostenrechnung)
965      * @param	herstellEinzelKosten	Die Herstell-Einzel-Kosten (Vollkostenrechnung)
966      * @param	herstellGemeinkosten	Die Herstell-Gemein-Kosten (Vollkostenrechnung)
967      * @return	Die Vollkosten (Vollkostenrechnung)
968      */
969     public static final double vollkosten(final double vertriebskosten, final double herstellEinzelKosten, final double herstellGemeinkosten)
970     {
971         double ergebnis = (vertriebskosten + herstellEinzelKosten + herstellGemeinkosten);
972 
973         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
974         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
975 
976         return rueckgabewert;
977     }
978 
979     /***
980      * Liefert die Herstell-Einzel-Kosten (Vollkostenrechnung) zur&uuml;ck
981      *
982      * @param	herstellEinzelKostenloehne	Die Herstell-Einzel-Kosten Lohnkosten
983      * @param	herstellEinzelKostenUeberstundenzuschlag	Die Herstell-Einzel-Kosten &Uuml;berstundenzuschlagskosten
984      * @param	herstellEinzelKostenRohstoffe	Die Herstell-Einzel-Kosten Rohstoffkosten
985      * @return	Die Herstell-Einzel-Kosten (Vollkostenrechnung)
986      */
987     public static final double herstellEinzelKosten(final double herstellEinzelKostenloehne, final double herstellEinzelKostenUeberstundenzuschlag, final double herstellEinzelKostenRohstoffe)
988     {
989         double ergebnis = (herstellEinzelKostenloehne + herstellEinzelKostenUeberstundenzuschlag + herstellEinzelKostenRohstoffe);
990 
991         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
992         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
993 
994         return rueckgabewert;
995     }
996 
997     /***
998      * Liefert die Vertriebskosten (Vollkostenrechnung) zur&uuml;ck
999      *
1000      * @param	vertriebsKostenMarketing	Die Vertriebskosten Marketingkosten
1001      * @param	vertriebsKostenLagerungFertigprodukte	Die Vertriebskosten Fertigproduktlagerungskosten
1002      * @param	vertriebsKostenBeratungUndMarktforschung	Die Vertriebskosten Beratungs- und Marktforschungskosten
1003      * @return	Die Vertriebskosten (Vollkostenrechnung)
1004      */
1005     public static final double vertriebskosten(final double vertriebsKostenMarketing, final double vertriebsKostenLagerungFertigprodukte, final double vertriebsKostenBeratungUndMarktforschung)
1006     {
1007         double ergebnis = (vertriebsKostenMarketing + vertriebsKostenLagerungFertigprodukte + vertriebsKostenBeratungUndMarktforschung);
1008 
1009         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1010         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1011 
1012         return rueckgabewert;
1013     }
1014 
1015     /***
1016      * Liefert die Herstell-Gemein-Kosten (Vollkostenrechnung) zur&uuml;ck
1017      *
1018      * @param	herstellGemeinKostenRohstoffe	Die Herstell-Gemein-Kosten Rohstoffkosten
1019      * @param	herstellGemeinKostenAbschreibungUndAnlagenprojektierung	Die Herstell-Gemein-Kosten Abschreibungs- und Anlagenprojektierungskosten
1020      * @param	herstellGemeinKostenQualitaetssicherung	Die Herstell-Gemein-Kosten Qualit&auml;tssicherungskosten
1021      * @param	herstellGemeinKostenSchichtwechsel	Die Herstell-Gemein-Kosten Schichtwechselkosten
1022      * @param	herstellGemeinKostenForschungUndEntwicklung	Die Herstell-Gemein-Kosten Forschungs- und Entwicklungskosten
1023      * @param	herstellGemeinKostenZinsen	Die Herstell-Gemein-Kosten Zinskosten
1024      * @param	herstellGemeinKostenVerwaltung	Die Herstell-Gemein-Kosten Verwaltungskosten
1025      * @return	Die Herstell-Gemein-Kosten (Vollkostenrechnung)
1026      */
1027     public static final double herstellGemeinKosten(
1028         final double herstellGemeinKostenRohstoffe,
1029         final double herstellGemeinKostenAbschreibungUndAnlagenprojektierung,
1030         final double herstellGemeinKostenQualitaetssicherung,
1031         final double herstellGemeinKostenSchichtwechsel,
1032         final double herstellGemeinKostenForschungUndEntwicklung,
1033         final double herstellGemeinKostenZinsen,
1034         final double herstellGemeinKostenVerwaltung)
1035     {
1036         double ergebnis = (herstellGemeinKostenRohstoffe + herstellGemeinKostenAbschreibungUndAnlagenprojektierung + herstellGemeinKostenQualitaetssicherung + herstellGemeinKostenSchichtwechsel + herstellGemeinKostenForschungUndEntwicklung + herstellGemeinKostenZinsen + herstellGemeinKostenVerwaltung);
1037 
1038         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1039         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1040 
1041         return rueckgabewert;
1042     }
1043 
1044     /***
1045      * Liefert die Vertriebs-Marketingkosten (Vollkostenrechnung) zur&uuml;ck
1046      * Marketingkosten aus Tabelle 21 Zeile 12
1047      *
1048      * @param	marketingkosten	Die Marketingkosten
1049      * @param	abgesetzteStueck	Die abgesetzte St&uuml;ckzahl
1050      * @return	Die Vertriebs-Marketingkosten (Vollkostenrechnung)
1051      */
1052     public static final double vertriebsKostenMarketing(final double marketingkosten, final double abgesetzteStueck)
1053     {
1054         double ergebnis = 0.0;
1055 
1056         if (abgesetzteStueck > 0)
1057             ergebnis = (marketingkosten / abgesetzteStueck);
1058         else
1059             ergebnis = (marketingkosten);
1060 
1061         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1062         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1063 
1064         return rueckgabewert;
1065     }
1066 
1067     /***
1068      * Liefert die Vertriebskosten f&uuml;r die Lagerung von Fertigprodukten (Vollkostenrechnung) zur&uuml;ck
1069      * Lagerungskosten Fertigprodukte aus Tabelle 21 Zeile 15
1070      *
1071      * @param	lagerungsKostenFertigprodukte	Die Kosten f&uuml;r die Lagerung von Fertigprodukten
1072      * @param	abgesetzteStueck	Die abgesetzte St&uuml;ckzahl
1073      * @return	Die Vertriebskosten f&uuml;r die Lagerung von Fertigprodukten (Vollkostenrechnung)
1074      */
1075     public static final double vertriebsKostenLagerungFertigprodukte(final double lagerungsKostenFertigprodukte, final double abgesetzteStueck)
1076     {
1077         double ergebnis = 0.0;
1078 
1079         if (abgesetzteStueck > 0)
1080             ergebnis = (lagerungsKostenFertigprodukte / abgesetzteStueck);
1081         else
1082             ergebnis = (lagerungsKostenFertigprodukte);
1083 
1084         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1085         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1086 
1087         return rueckgabewert;
1088     }
1089 
1090     /***
1091      * Liefert die Vertriebskosten f&uuml;r die Beratung und Marktforschung (Vollkostenrechnung) zur&uuml;ck
1092      * Marktforschung und Beratung aus Tabelle 21 Zeile 16 + 42
1093      *
1094      * @param	marktforschung	Die Marktforschungskosten
1095      * @param	beratung	Die Beratungskosten
1096      * @param	abgesetzteStueck	Die abgesetzte St&uuml;ckzahl
1097      * @return	Die Vertriebskosten f&uuml;r die Beratung und Marktforschung (Vollkostenrechnung)
1098      */
1099     public static final double vertriebsKostenBeratungUndMarktforschung(final double marktforschung, final double beratung, final double abgesetzteStueck)
1100     {
1101         double ergebnis = 0.0;
1102 
1103         if (abgesetzteStueck > 0)
1104             ergebnis = ((marktforschung + beratung) / abgesetzteStueck);
1105         else
1106             ergebnis = ((marktforschung + beratung));
1107 
1108         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1109         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1110 
1111         return rueckgabewert;
1112     }
1113 
1114     /***
1115      * Liefert die Herstell-Einzel-Kosten Lohnkosten (Vollkostenrechnung) zur&uuml;ck
1116      * Alte Fertigungskosten aus Tabelle 21 Zeile 26
1117      *
1118      * @param	fertigungslohnkosten	Die Fertigungslohnkosten
1119      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1120      * @return	Die Herstell-Einzel-Kosten Lohnkosten (Vollkostenrechnung)
1121      */
1122     public static final double herstellEinzelKostenLoehne(final double fertigungslohnkosten, final double guteProduktionsmenge)
1123     {
1124         double ergebnis = 0.0;
1125 
1126         if (guteProduktionsmenge > 0)
1127             ergebnis = (fertigungslohnkosten / guteProduktionsmenge);
1128         else
1129             ergebnis = (fertigungslohnkosten);
1130 
1131         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1132         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1133 
1134         return rueckgabewert;
1135     }
1136 
1137     /***
1138      * Liefert die Herstell-Einzel-Kosten &Uuml;berstundenlohnkosten (Vollkostenrechnung) zur&uuml;ck
1139      * &Uuml;berstundenzuschlag aus Tabelle 21 Zeile 27
1140      *
1141      * @param	ueberstundenzuschlag	Die &Uuml;berstundenzuschl&auml;ge
1142      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1143      * @return	Die Herstell-Einzel-Kosten &Uuml;berstundenlohnkosten (Vollkostenrechnung)
1144      */
1145     public static final double herstellEinzelKostenUeberstunden(final double ueberstundenzuschlag, final double guteProduktionsmenge)
1146     {
1147         double ergebnis = 0.0;
1148 
1149         if (guteProduktionsmenge > 0)
1150             ergebnis = (ueberstundenzuschlag / guteProduktionsmenge);
1151         else
1152             ergebnis = (ueberstundenzuschlag);
1153 
1154         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1155         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1156 
1157         return rueckgabewert;
1158     }
1159 
1160     /***
1161      * Liefert die Herstell-Einzel-Kosten Rohstoffverbrauchskosten (Vollkostenrechnung) zur&uuml;ck
1162      * Rohstoffverbrauchskosten aus Tabelle 21 Zeile 32
1163      *
1164      * @param	rohstoffverbrauchkosten	Die Rohstoffverbrauchskosten
1165      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1166      * @return	Die Herstell-Einzel-Kosten Rohstoffverbrauchskosten (Vollkostenrechnung)
1167      */
1168     public static final double herstellEinzelKostenRohstoffe(final double rohstoffverbrauchkosten, final double guteProduktionsmenge)
1169     {
1170         double ergebnis = 0.0;
1171 
1172         if (guteProduktionsmenge > 0)
1173             ergebnis = (rohstoffverbrauchkosten / guteProduktionsmenge);
1174         else
1175             ergebnis = (rohstoffverbrauchkosten);
1176 
1177         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1178         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1179 
1180         return rueckgabewert;
1181     }
1182 
1183     /***
1184      * Liefert die Herstell-Gemein-Kosten Rohstoffkosten (Vollkostenrechnung) zur&uuml;ck
1185      * Rohstofflagerung und -bestellung aus Tabelle 21 Zeile 33+34
1186      *
1187      * @param	rohstofflagerung	Die Rohstofflagerungskosten
1188      * @param	rohstoffbestellung	Die Rohstoffbestellungskosten
1189      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1190      * @return	Die Herstell-Gemein-Kosten Rohstoffkosten (Vollkostenrechnung)
1191      */
1192     public static final double herstellGemeinKostenRohstoffe(final double rohstofflagerung, final double rohstoffbestellung, final double guteProduktionsmenge)
1193     {
1194         double ergebnis = 0.0;
1195 
1196         if (guteProduktionsmenge > 0)
1197             ergebnis = ((rohstofflagerung + rohstoffbestellung) / guteProduktionsmenge);
1198         else
1199             ergebnis = (rohstofflagerung + rohstoffbestellung);
1200 
1201         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1202         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1203 
1204         return rueckgabewert;
1205     }
1206 
1207     /***
1208      * Liefert die Herstell-Gemein-Kosten Abschreibungs- und Anlagenprojektierungskosten (Vollkostenrechnung) zur&uuml;ck
1209      * Abschreibung und Anlagenprojektierung aus Tabelle 21 Zeile 29 + 31
1210      *
1211      * @param	abschreibung	Die Abschreibungskosten
1212      * @param	anlagenprojektierung	Die Anlagenprojektierungskosten
1213      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1214      * @return	Die Herstell-Gemein-Kosten Abschreibungs- und Anlagenprojektierungskosten (Vollkostenrechnung)
1215      */
1216     public static final double herstellGemeinKostenAbschreibungUndAnlagenprojektierung(final double abschreibung, final double anlagenprojektierung, final double guteProduktionsmenge)
1217     {
1218         double ergebnis = 0.0;
1219 
1220         if (guteProduktionsmenge > 0)
1221             ergebnis = ((abschreibung + anlagenprojektierung) / guteProduktionsmenge);
1222         else
1223             ergebnis = (abschreibung + anlagenprojektierung);
1224 
1225         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1226         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1227 
1228         return rueckgabewert;
1229     }
1230 
1231     /***
1232      * Liefert die Herstell-Gemein-Kosten Qualit&auml;tssicherungskosten (Vollkostenrechnung) zur&uuml;ck
1233      * Qualit&auml;tssicherung aus Tabelle 21 Zeile 25
1234      *
1235      * @param	qualitaetssicherung	Die Qualit&auml;tssicherungskosten
1236      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1237      * @return	Die Herstell-Gemein-Kosten Qualit&auml;tssicherungskosten (Vollkostenrechnung)
1238      */
1239     public static final double herstellGemeinKostenQualitaetssicherung(final double qualitaetssicherung, final double guteProduktionsmenge)
1240     {
1241         double ergebnis = 0.0;
1242 
1243         if (guteProduktionsmenge > 0)
1244             ergebnis = (qualitaetssicherung / guteProduktionsmenge);
1245         else
1246             ergebnis = (qualitaetssicherung);
1247 
1248         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1249         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1250 
1251         return rueckgabewert;
1252     }
1253 
1254     /***
1255      * Liefert ie Herstell-Gemein-Kosten Schichtwechselkosten (Vollkostenrechnung) zur&uuml;ck
1256      * Schichtwechselkosten aus Tabelle 21 Zeile 28
1257      *
1258      * @param	schichtwechselKosten	Die Schichtwechselkosten
1259      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1260      * @return	Die Herstell-Gemein-Kosten Schichtwechselkosten (Vollkostenrechnung)
1261      */
1262     public static final double herstellGemeinKostenSchichtwechsel(final double schichtwechselKosten, final double guteProduktionsmenge)
1263     {
1264         double ergebnis = 0.0;
1265 
1266         if (guteProduktionsmenge > 0)
1267             ergebnis = (schichtwechselKosten / guteProduktionsmenge);
1268         else
1269             ergebnis = (schichtwechselKosten);
1270 
1271         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1272         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1273 
1274         return rueckgabewert;
1275     }
1276 
1277     /***
1278      * Liefert ie Herstell-Gemein-Kosten Forschungs- und Entwicklungskosten (Vollkostenrechnung) zur&uuml;ck
1279      * Forschung und Entwicklung aus Tabelle 21 Zeile 21
1280      *
1281      * @param	forschungUndEntwicklung	Die Forschungs- und Entwicklungskosten
1282      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1283      * @return	Die Herstell-Gemein-Kosten Forschungs- und Entwicklungskosten (Vollkostenrechnung)
1284      */
1285     public static final double herstellGemeinKostenForschungUndEntwicklung(final double forschungUndEntwicklung, final double guteProduktionsmenge)
1286     {
1287         double ergebnis = 0.0;
1288 
1289         if (guteProduktionsmenge > 0)
1290             ergebnis = (forschungUndEntwicklung / guteProduktionsmenge);
1291         else
1292             ergebnis = (forschungUndEntwicklung);
1293 
1294         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1295         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1296 
1297         return rueckgabewert;
1298     }
1299 
1300     /***
1301      * Liefert ie Herstell-Gemein-Kosten Zinskosten (Vollkostenrechnung) zur&uuml;ck
1302      * Zinsen aus Tabelle 21 Zeile 43 + 44
1303      *
1304      * @param	zinsenUeberziehungskredit	Die Zinskosten f&uuml;r den &Uuml;berziehungskredit
1305      * @param	zinsenVereinbartKredit	Die Zinskosten f&uuml;r den vereinbarten Kredit
1306      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1307      * @return	Die Herstell-Gemein-Kosten Zinskosten (Vollkostenrechnung)
1308      */
1309     public static final double herstellGemeinKostenZinsen(final double zinsenUeberziehungskredit, final double zinsenVereinbartKredit, final double guteProduktionsmenge)
1310     {
1311         double ergebnis = 0.0;
1312 
1313         if (guteProduktionsmenge > 0)
1314             ergebnis = ((zinsenUeberziehungskredit + zinsenVereinbartKredit) / guteProduktionsmenge);
1315         else
1316             ergebnis = (zinsenUeberziehungskredit + zinsenVereinbartKredit);
1317 
1318         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1319         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1320 
1321         return rueckgabewert;
1322     }
1323 
1324     /***
1325      * Liefert ie Herstell-Gemein-Kosten Verwaltungskosten (Vollkostenrechnung) zur&uuml;ck
1326      * Verwaltungskosten aus Tabelle 21 Zeile 41
1327      *
1328      * @param	verwaltung	Die Verwaltungskosten
1329      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1330      * @return	Die Herstell-Gemein-Kosten Verwaltungskosten (Vollkostenrechnung)
1331      */
1332     public static final double herstellGemeinKostenVerwaltung(final double verwaltung, final double guteProduktionsmenge)
1333     {
1334         double ergebnis = 0.0;
1335 
1336         if (guteProduktionsmenge > 0)
1337             ergebnis = (verwaltung / guteProduktionsmenge);
1338         else
1339             ergebnis = (verwaltung);
1340         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1341         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1342 
1343         return rueckgabewert;
1344     }
1345 
1346     /***
1347      * Liefert den Gewinn (Vollkostenrechnung) zur&uuml;ck
1348      *
1349      * @param	erloes	Die Erl&ouml;se
1350      * @param	kosten	Die Kosten
1351      * @return	Der Gewinn (Vollkostenrechnung)
1352      */
1353     public static final double gewinn(final double erloes, final double kosten)
1354     {
1355         double ergebnis = (erloes + kosten);
1356 
1357         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1358         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1359 
1360         return rueckgabewert;
1361     }
1362 
1363     //	-------------------------------------------
1364     //	Grenz - Kostenrechnung
1365     //	-------------------------------------------
1366 
1367     //	Tabelle A.1.2: Planungsbogen zur Grenz - Kostenrechnung
1368 
1369     /***
1370      * Liefert die Zahl der in der letzten Zone produzierten Fertigprodukte zur&uuml;ck
1371      *
1372      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1373      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1374      * @return	Die Zahl der in der letzten Zone produzierten Fertigprodukte
1375      */
1376     public static final double produktionInDerLetztenZone(final double kapazitaetsauslastung, final double guteProduktionsmenge)
1377     {
1378         double ergebnis = 0.0;
1379 
1380         double sektor = 0.0;
1381         double rest = 0.0;
1382 
1383         if (kapazitaetsauslastung < 100)
1384             ergebnis = guteProduktionsmenge;
1385         else
1386         {
1387             sektor = kapazitaetsauslastung / 50.0;
1388             rest = sektor % 1;
1389             sektor = sektor - rest;
1390 
1391             ergebnis = ((guteProduktionsmenge / kapazitaetsauslastung) * (kapazitaetsauslastung - (sektor * 50.0)));
1392         }
1393 
1394         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1395         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1396 
1397         return rueckgabewert;
1398     }
1399 
1400     /***
1401      * Liefert die Grenz-Herstell-Kosten zur&uuml;ck
1402      *
1403      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1404      * @param	grenzHerstellKostenLoehne	Die Grenz-Herstell-Kosten Lohnkosten
1405      * @param	grenzHerstellKostenUeberstunden	Die Grenz-Herstell-Kosten &Uuml;berstundenlohnkosten
1406      * @param	grenzHerstellKostenRohstoffe	Die Grenz-Herstell-Kosten Rohstoffkosten
1407      * @param	grenzHerstellKostenQualitaetssicherung	Die Grenz-Herstell-Kosten Qualit&auml;tssicherungskosten
1408      * @param	grenzHerstellKostenSchichtwechsel	Die Grenz-Herstell-Kosten Schichtwechselkosten
1409      * @param	grenzHerstellKostenVerwaltung	Die Grenz-Herstell-Kosten Verwaltungskosten
1410      * @return	Die Grenz-Herstell-Kosten
1411      */
1412     public static final double grenzHerstellKosten(final double kapazitaetsauslastung, final double grenzHerstellKostenLoehne, final double grenzHerstellKostenUeberstunden, final double grenzHerstellKostenRohstoffe, final double grenzHerstellKostenQualitaetssicherung, final double grenzHerstellKostenSchichtwechsel, final double grenzHerstellKostenVerwaltung)
1413     {
1414         double ergebnis = (grenzHerstellKostenLoehne + grenzHerstellKostenUeberstunden + grenzHerstellKostenRohstoffe + grenzHerstellKostenQualitaetssicherung + grenzHerstellKostenSchichtwechsel + grenzHerstellKostenVerwaltung);
1415 
1416         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1417         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1418 
1419         return rueckgabewert;
1420     }
1421 
1422     /***
1423      * Liefert die Grenz-Herstell-Kosten f&uuml;r die Fertigungslohnkosten zur&uuml;ck
1424      * Fertigungslohnkosten aus Tabelle 21 Zeile 26
1425      *
1426      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1427      * @param	fertigungsLohnKosten	Die Fertigungslohnkosten
1428      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1429      * @return	Die Grenz-Herstell-Kosten f&uuml;r die Fertigungslohnkosten
1430      */
1431     public static final double grenzHerstellKostenLoehne(final double kapazitaetsauslastung, final double fertigungsLohnKosten, final double guteProduktionsmenge)
1432     {
1433         double ergebnis = 0.0;
1434 
1435         if (guteProduktionsmenge > 0)
1436             ergebnis = (fertigungsLohnKosten / guteProduktionsmenge);
1437         else
1438             ergebnis = (fertigungsLohnKosten);
1439 
1440         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1441         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1442 
1443         return rueckgabewert;
1444     }
1445 
1446     /***
1447      * Liefert die Grenz-Herstell-Kosten f&uuml;r die &Uuml;berstunden zur&uuml;ck
1448      * &Uuml;berstundenzuschlag aus der Tabelle 21 Zeile 27
1449      *
1450      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1451      * @param	ueberstunden	Die &Uuml;berstundenkosten
1452      * @param	produktionInDerLetztenZone	Die Zahl der in der letzten Zone produzierten Fertigprodukte
1453      * @return	Die Grenz-Herstell-Kosten f&uuml;r die &Uuml;berstunden
1454      */
1455     public static final double grenzHerstellKostenUeberstunden(final double kapazitaetsauslastung, final double ueberstunden, final double produktionInDerLetztenZone)
1456     {
1457         double ergebnis = 0.0;
1458 
1459         if ((kapazitaetsauslastung < 100) || (ueberstunden == 0))
1460             ergebnis = 0;
1461         else
1462             ergebnis = (ueberstunden / produktionInDerLetztenZone);
1463 
1464         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1465         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1466 
1467         return rueckgabewert;
1468     }
1469 
1470     /***
1471      * Liefert die Grenz-Herstell-Kosten f&uuml;r die Rohstoffe zur&uuml;ck
1472      * Rohstoffe aus Tabelle 21 Zeile 32
1473      *
1474      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1475      * @param	rohstoffe	Die Rohstoffkosten
1476      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1477      * @return	Die Grenz-Herstell-Kosten f&uuml;r die Rohstoffe
1478      */
1479     public static final double grenzHerstellKostenRohstoffe(final double kapazitaetsauslastung, final double rohstoffe, final double guteProduktionsmenge)
1480     {
1481         double ergebnis = 0.0;
1482 
1483         if (guteProduktionsmenge > 0)
1484             ergebnis = (rohstoffe / guteProduktionsmenge);
1485         else
1486             ergebnis = (rohstoffe);
1487 
1488         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1489         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1490 
1491         return rueckgabewert;
1492     }
1493 
1494     /***
1495      * Liefert die Grenz-Herstell-Kosten f&uuml;r die Qualit&auml;tssicherung zur&uuml;ck
1496      * Qualit&auml;tssicherung aus Tabelle 21 Zeile 25
1497      *
1498      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1499      * @param	qualitaetssicherung	Die Qualit&auml;tssicherungskosten
1500      * @param	guteProduktionsmenge	Die Produktionsmenge an guten St&uuml;ck
1501      * @return	Die Grenz-Herstell-Kosten f&uuml;r die Qualit&auml;tssicherung
1502      */
1503     public static final double grenzHerstellKostenQualitaetssicherung(final double kapazitaetsauslastung, final double qualitaetssicherung, final double guteProduktionsmenge)
1504     {
1505         double ergebnis = 0.0;
1506 
1507         if (guteProduktionsmenge > 0)
1508             ergebnis = (qualitaetssicherung / guteProduktionsmenge);
1509         else
1510             ergebnis = (qualitaetssicherung);
1511 
1512         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1513         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1514 
1515         return rueckgabewert;
1516     }
1517 
1518     /***
1519      * Liefert die Grenz-Herstell-Kosten f&uuml;r den Schichtwechsel zur&uuml;ck
1520      * Schichtwechselkosten aus Tabelle 21 Zeile 28
1521      *
1522      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1523      * @param	schichtwechsel	Die Schichtwechselkosten
1524      * @param	produktionInDerLetztenZone	Die Zahl der in der letzten Zone produzierten Fertigprodukte
1525      * @return	Die Grenz-Herstell-Kosten f&uuml;r den Schichtwechsel
1526      */
1527     public static final double grenzHerstellKostenSchichtwechsel(final double kapazitaetsauslastung, final double schichtwechsel, final double produktionInDerLetztenZone)
1528     {
1529         double ergebnis = 0.0;
1530 
1531         if ((kapazitaetsauslastung < 100) || (schichtwechsel == 0))
1532             ergebnis = 0;
1533         else if (produktionInDerLetztenZone > 0)
1534             ergebnis = (schichtwechsel / produktionInDerLetztenZone);
1535         else
1536             ergebnis = (schichtwechsel);
1537 
1538         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1539         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1540 
1541         return rueckgabewert;
1542     }
1543 
1544     /***
1545      * Liefert die Grenz-Herstell-Kosten der Verwaltung zur&uuml;ck
1546      * Verwaltung aus Tabelle 21 Zeile 41
1547      *
1548      * @param	lohnindex	Der Lohnindex
1549      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
1550      * @param	verwaltung	Die Verwaltungskosten
1551      * @param	produktionInDerLetztenZone	Die Zahl der in der letzten Zone produzierten Fertigprodukte
1552      * @param	verwaltungTabelle	ArrayList Tabelle mit den Zuordnungen Kapazit&auml;tsauslastung - Verwaltungskosten
1553      * @return	Die Grenz-Herstell-Kosten der Verwaltung
1554      */
1555     public static final double grenzHerstellKostenVerwaltung(final double lohnindex, final double kapazitaetsauslastung, final double verwaltung, final double produktionInDerLetztenZone, final ArrayList verwaltungTabelle)
1556     {
1557         double ergebnis = 0.0;
1558 
1559         int groesseVerwaltungTabelle = verwaltungTabelle.size();
1560 
1561         for (int i = 0; i < groesseVerwaltungTabelle - 1; i++)
1562         {
1563             if (kapazitaetsauslastung >= ((Verwaltungskosten) verwaltungTabelle.get(i)).getKapazitaetsauslastung() && kapazitaetsauslastung < ((Verwaltungskosten) verwaltungTabelle.get(i + 1)).getKapazitaetsauslastung())
1564             {
1565                 ergebnis = (verwaltung - ((Verwaltungskosten) verwaltungTabelle.get(i)).getKosten() * lohnindex) / produktionInDerLetztenZone;
1566                 break;
1567             }
1568             else if (kapazitaetsauslastung < ((Verwaltungskosten) verwaltungTabelle.get(i)).getKapazitaetsauslastung())
1569             {
1570                 ergebnis = (verwaltung - ((Verwaltungskosten) verwaltungTabelle.get(i)).getKosten() * lohnindex) / produktionInDerLetztenZone;
1571                 break;
1572             }
1573         }
1574 
1575         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1576         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1577 
1578         return rueckgabewert;
1579     }
1580 
1581     /***
1582      * Liefert den Grenzgewinn zur&uuml;ck
1583      * Beachte: die Grenz - Marketingkosten und die Grenz - Herstellkosten sind negativ
1584      *
1585      * @param	grenzErloes	Der Grenzerl&ouml;s
1586      * @param	grenzMarketing	Das Grenzmarketing
1587      * @param	grenzHerstellkosten	Die Grenzherstellkosten
1588      * @return	Der Grenzgewinn
1589      */
1590     public static final double grenzGewinn(final double grenzErloes, final double grenzMarketing, final double grenzHerstellkosten)
1591     {
1592         double ergebnis = (grenzErloes + grenzMarketing + grenzHerstellkosten);
1593 
1594         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1595         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1596 
1597         return rueckgabewert;
1598     }
1599 
1600     /***
1601      * Liefert den  zur&uuml;ck
1602      *
1603      * @param
1604      * @param
1605      * @return
1606      */
1607     /*
1608         public static final double (double , double )
1609         {
1610             double ergebnis = ;
1611 
1612             // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
1613             double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
1614 
1615             return rueckgabewert;
1616         }
1617     */
1618 }