////////////////////////////////////////////////////////////////////////////////
   //CabaWeb
   //Copyright (C) 2004  Thomas Vogt <Thomas.Vogt@TVC-Software.com>
   //
   //This library is free software; you can redistribute it and/or
   //modify it under the terms of the GNU Lesser General Public
   //License as published by the Free Software Foundation; either
   //version 2.1 of the License, or (at your option) any later version.
   //
  //This library is distributed in the hope that it will be useful,
  //but WITHOUT ANY WARRANTY; without even the implied warranty of
  //MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  //Lesser General Public License for more details.
  //
  //You should have received a copy of the GNU Lesser General Public
  //License along with this library; if not, write to the Free Software
  //Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  
  package org.fhw.cabaweb.math;
  
  import java.util.ArrayList;
  
  import org.fhw.cabaweb.data.dataobjects.Qualitaetssicherung;
  import org.fhw.cabaweb.data.dataobjects.Verwaltungskosten;
  
  /***
   * Klasse mit den Berechnungsfunktionen f&uuml;r die Produktion
   *
   * @author	<a href="mailto:thomas.vogt@tvc-software.com">Thomas Vogt</a>
   * @version	Version 1.0 16.03-05.04.2004
   */
  public final class Produktion
  {
      /***
       * Standardkonstruktor der nicht zug&auml;nglich sein soll, da dies eine Utility Klasse ist
       */
      protected Produktion()
      {
          throw new UnsupportedOperationException(); // Aufrufe aus eventuellen SubKlassen verhindern
      }
  
      /***
       * Interface mit den ben&ouml;tigten Konstanten
       */
      interface Konstanten
      {
          /***
           * Zahl die Hundert Prozent repr&auml;sentiert (100.0)
           */
          public static final double HUNDRED_PERCENT = 100.0;
      }
  
      /***
       * Liefert die optimale Qualit&auml;tssicherung zur&uuml;ck
       *
       * @param	guteProduktionsmenge	Die gute Produktionsmenge
       * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
       * @param	kapazitaetsbestandDiesesQuartal	Der Kapazit&auml;tsbestand an Stunden f&uuml;r diese Quartal
       * @param	fertigungsstueckzeit	Die Fertigungsst&uuml;ckzeit
       * @param	grundlohnkosten	Die Grundlohnkosten
       * @param	lohnindex	Der Lohnerh&ouml;hungsindex
       * @param	rohstoffverbrauch	Der Rohstoffverbrauch
       * @param	rohstoffwert	Der Rohstoffwert
       * @param	inflationsindex	Der Inflationsindex
       * @param	ueberstundenzuschlag	Der &uuml;berstundenzuschlag
       * @param	nacharbeitsaufwand		Der Nacharbeitsaufwand
       * @param	qualitaetssicherungTabelle	Die ArrayList Tabelle mit den Zuordnungen QSAufwendungen - Fehlerrate - Ausschussrate
       * @return	Die optimale Qualit&auml;tssicherung
       */
      public static final double qualitaetssicherungOptimal(
          final double guteProduktionsmenge,
          final double kapazitaetsauslastung,
          final double kapazitaetsbestandDiesesQuartal,
          final double fertigungsstueckzeit,
          final double grundlohnkosten,
          final double lohnindex,
          final double rohstoffverbrauch,
          final double rohstoffwert,
          final double inflationsindex,
          final double ueberstundenzuschlag,
          final double nacharbeitsaufwand,
          final ArrayList qualitaetssicherungTabelle)
      {
          double ergebnis = 0.0;
  
          double qualitaetssicherungNominal = 0.0;
          double qualitaetssicherungOptimal = 0.0;
          double qualitaetskostenOptimal = 99999999.0;
          double qualitaetskostenTemp = 0.0;
  
          int groesseQualitaetssicherungTabelle = qualitaetssicherungTabelle.size();
  
          for (int i = 0; i <= (int) (((Qualitaetssicherung) qualitaetssicherungTabelle.get(groesseQualitaetssicherungTabelle - 1)).getQualitaetssicherungsausgaben() * 100); i++)
          {
              double qualtaetssicherungRealA = qualtaetssicherungReal(qualitaetssicherungNominal, inflationsindex);
              double fehleranteilA = fehleranteil(qualtaetssicherungRealA, qualitaetssicherungTabelle) / Konstanten.HUNDRED_PERCENT;
              double ausschussA = ausschuss(fehleranteilA);
              double pmNominal = produktionsmengeNominal(guteProduktionsmenge, (ausschussA * Konstanten.HUNDRED_PERCENT));
             double ausschusskostenA = ausschusskosten(pmNominal, ausschussA, fertigungsstueckzeit, grundlohnkosten, lohnindex, rohstoffverbrauch, rohstoffwert, kapazitaetsauslastung);
 
             double tempd2 = fertigungszeitOhneUeberstundenOhneNacharbeit(pmNominal, fertigungsstueckzeit);
             double tempd3 = grundlohnkosten * lohnindex;
             double tempd4 = nacharbeitsZeitOhneUeberstunden(((fehleranteilA - ausschussA) * pmNominal), fertigungsstueckzeit, (nacharbeitsaufwand - 1.0));
             double tempd5 = normalkapazitaet(kapazitaetsauslastung, kapazitaetsbestandDiesesQuartal);
             double tempd7 = fertigungszeitGesamtFertigungsLohnKosten(pmNominal, fertigungsstueckzeit, ((fehleranteilA - ausschussA) * pmNominal));
 
             double nacharbeitslohnkostenOhneUeberstundenA = nacharbeitslohnkostenOhneUeberstunden(tempd4, tempd3);
             double ueberstundenzuschlagNacharbeitA = ueberstundenzuschlagNacharbeit(nacharbeitslohnkostenOhneUeberstundenA, tempd7, tempd2, tempd4, tempd5, tempd3);
             double nacharbeitskostenA = lohnkosten(nacharbeitslohnkostenOhneUeberstundenA, ueberstundenzuschlagNacharbeitA);
 
             double fehlerkostenA = fehlerkosten(ausschusskostenA, nacharbeitskostenA);
 
             qualitaetskostenTemp = qualitaetskosten(pmNominal, inflationsindex, qualtaetssicherungRealA, fehlerkostenA);
 
             if (qualitaetskostenTemp <= qualitaetskostenOptimal)
             {
                 qualitaetskostenOptimal = qualitaetskostenTemp;
                 qualitaetssicherungOptimal = qualitaetssicherungNominal;
             }
 
             qualitaetssicherungNominal += 0.01;
         }
 
         ergebnis = qualitaetskostenOptimal;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den normale Qualit&auml;tssicherung zur&uuml;ck
      *
      * @param	guteProduktionsmenge	Die gute Produktionsmenge
      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
      * @param	kapazitaetsbestandDiesesQuartal	Der Kapazit&auml;tsbestand an Stunden f&uuml;r diese Quartal
      * @param	fertigungsstueckzeit	Die Fertigungsst&uuml;ckzeit
      * @param	grundlohnkosten	Die Grundlohnkosten
      * @param	lohnindex	Der Lohnerh&ouml;hungsindex
      * @param	rohstoffverbrauch	Der Rohstoffverbrauch
      * @param	rohstoffwert	Der Rohstoffwert
      * @param	inflationsindex	Der Inflationsindex
      * @param	ueberstundenzuschlag	Der &uuml;berstundenzuschlag
      * @param	nacharbeitsaufwand		Der Nacharbeitsaufwand
      * @param	qualitaetssicherungNominal	Die nominalen QSAufwendungen gem&auml;ß Unternehmensentscheidung
      * @param	qualitaetssicherungTabelle	Die ArrayList Tabelle mit den Zuordnungen QSAufwendungen - Fehlerrate - Ausschussrate
      * @return	Die normale Qualit&auml;tssicherung
      */
     public static final double qualitaetssicherungNormal(
         final double guteProduktionsmenge,
         final double kapazitaetsauslastung,
         final double kapazitaetsbestandDiesesQuartal,
         final double fertigungsstueckzeit,
         final double grundlohnkosten,
         final double lohnindex,
         final double rohstoffverbrauch,
         final double rohstoffwert,
         final double inflationsindex,
         final double ueberstundenzuschlag,
         final double nacharbeitsaufwand,
         final double qualitaetssicherungNominal,
         final ArrayList qualitaetssicherungTabelle)
     {
         double ergebnis = 0.0;
 
         double qualitaetskostenNormal = 0.0;
 
         double qualtaetssicherungRealA = qualtaetssicherungReal(qualitaetssicherungNominal, inflationsindex);
         double fehleranteilA = fehleranteil(qualtaetssicherungRealA, qualitaetssicherungTabelle) / Konstanten.HUNDRED_PERCENT;
         double ausschussA = ausschuss(fehleranteilA);
         double pmNominal = produktionsmengeNominal(guteProduktionsmenge, (ausschussA * Konstanten.HUNDRED_PERCENT));
         double ausschusskostenA = ausschusskosten(pmNominal, ausschussA, fertigungsstueckzeit, grundlohnkosten, lohnindex, rohstoffverbrauch, rohstoffwert, kapazitaetsauslastung);
 
         double tempd2 = fertigungszeitOhneUeberstundenOhneNacharbeit(pmNominal, fertigungsstueckzeit);
         double tempd3 = grundlohnkosten * lohnindex;
         double tempd4 = nacharbeitsZeitOhneUeberstunden(((fehleranteilA - ausschussA) * pmNominal), fertigungsstueckzeit, (nacharbeitsaufwand - 1.0));
         double tempd5 = normalkapazitaet(kapazitaetsauslastung, kapazitaetsbestandDiesesQuartal);
         double tempd7 = fertigungszeitGesamtFertigungsLohnKosten(pmNominal, fertigungsstueckzeit, ((fehleranteilA - ausschussA) * pmNominal));
 
         double nacharbeitslohnkostenOhneUeberstundenA = nacharbeitslohnkostenOhneUeberstunden(tempd4, tempd3);
         double ueberstundenzuschlagNacharbeitA = ueberstundenzuschlagNacharbeit(nacharbeitslohnkostenOhneUeberstundenA, tempd7, tempd2, tempd4, tempd5, tempd3);
         double nacharbeitskostenA = lohnkosten(nacharbeitslohnkostenOhneUeberstundenA, ueberstundenzuschlagNacharbeitA);
 
         double fehlerkostenA = fehlerkosten(ausschusskostenA, nacharbeitskostenA);
         qualitaetskostenNormal = qualitaetskosten(pmNominal, inflationsindex, qualtaetssicherungRealA, fehlerkostenA);
 
         ergebnis = qualitaetskostenNormal;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Herstellkosten zur&uuml;ck
      *
      * @param	produktion	Die Produktionskosten
      * @param	beschaffung	Die Beschaffungskosten
      * @param	overhead	Der Overhead
      * @param	guteProduktionsmenge	Die gute Produktionsmenge
      * @return	Die Herstellkosten
      */
     public static final double herstellKostenBewertung(final double produktion, final double beschaffung, final double overhead, final double guteProduktionsmenge)
     {
         double ergebnis = 0.0;
 
         if (guteProduktionsmenge > 0)
             ergebnis = ((produktion + beschaffung + overhead) / guteProduktionsmenge);
         else
             ergebnis = ((produktion + beschaffung + overhead));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Quotient aus Lieferdefizit und Lagerbildung zur&uuml;ck
      *
      * @param	abgesetzteMenge	Die abgesetzte Menge
      * @param	absetzbareMenge	Die absetzbare Menge
      * @param	lieferdefizit	Das Lieferdefizt
      * @param	lagerbestand	Der Lagerbestand an Fertigprodukten
      * @return	Der Quotient aus Lieferdefizit und Lagerbildung
      */
     public static final double defizitUndLagerQuotient(final double abgesetzteMenge, final double absetzbareMenge, final double lieferdefizit, final double lagerbestand)
     {
         double ergebnis = 0.0;
 
         if ((absetzbareMenge - abgesetzteMenge) > 0)
         {
             ergebnis = (-Konstanten.HUNDRED_PERCENT * Common.divide(absetzbareMenge - abgesetzteMenge, abgesetzteMenge));
         }
         else
         {
             double temp = Konstanten.HUNDRED_PERCENT * Common.divide(lagerbestand - abgesetzteMenge * 0.1, abgesetzteMenge);
             ergebnis = (Math.max(0.0, temp));
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den optimalen Zinssatz zur&uuml;ck
      * Zinssatz Optimal
      *
      * @param	zuvielbezahlteZinsen	Die zuviel bezahlten Zinsen
      * @param	bankkreditVorquartal	Die H&ouml;he des Bankkredits im Vorquartal
      * @param	kontokorrentkreditVorquartal	Die H&ouml;he des Kontokorrentkredits im Vorquartal
      * @param	optimaleAenderungBankkredit	Die optimale &Auml;nderung des Bankkredits
      * @param	optimaleAenderungKontokorrentkredit	Die optimale &Auml;nderung des Kontokorrentkredits
      * @return	Der optimale Zinssatz
      */
     public static final double zinssatzOptimal(final double zuvielbezahlteZinsen, final double bankkreditVorquartal, final double kontokorrentkreditVorquartal, final double optimaleAenderungBankkredit, final double optimaleAenderungKontokorrentkredit)
     {
         double ergebnis = 0.0;
 
         if ((bankkreditVorquartal + optimaleAenderungBankkredit + kontokorrentkreditVorquartal + optimaleAenderungKontokorrentkredit) > 0)
             ergebnis = ((zuvielbezahlteZinsen / (bankkreditVorquartal + optimaleAenderungBankkredit + kontokorrentkreditVorquartal + optimaleAenderungKontokorrentkredit)) * Konstanten.HUNDRED_PERCENT);
         else
             ergebnis = 0.0;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Liquiditaets&auml;nderung bei eintreffen des geplanten Absatzes zur&uuml;ck
      *
      * @param	erfolgVorSteuern	Der Erfolg vor Steuern
      * @param	tatsaechlicheLiquiditaetsaenderung	Die tats&auml;chliche Liquiditaets&auml;nderung
      * @param	absatzReal	Der reale Absatz
      * @param	absatzGeplant	Der geplante Absatz
      * @param	nominellerPreis	Der nominelle Preis
      * @param	lagerkostenProStueck	Die Lagerkosten pro Fertigprodukt
      * @param	lohnkostenMitErhoehung	Die Lohnkosten inklusive Erh&ouml;hung
      * @param	rohstoffkosten	Die Rohstoffkosten
      * @return	Die Liquiditaets&auml;nderung bei eintreffen des geplanten Absatzes
      */
     public static final double liquiditaetsaenderungBeiGeplantemAbsatz(final double erfolgVorSteuern, final double tatsaechlicheLiquiditaetsaenderung, final double absatzReal, final double absatzGeplant, final double nominellerPreis, final double lagerkostenProStueck, final double lohnkostenMitErhoehung, final double rohstoffkosten)
     {
         double ergebnis = 0.0;
 
         double liquiditaetsaenderung = 0.0;
 
         if (erfolgVorSteuern <= 0)
         {
             liquiditaetsaenderung = tatsaechlicheLiquiditaetsaenderung - ((absatzReal - absatzGeplant) * (nominellerPreis + lagerkostenProStueck));
         }
         else if (erfolgVorSteuern > 0)
         {
             liquiditaetsaenderung = tatsaechlicheLiquiditaetsaenderung - ((absatzReal - absatzGeplant) * ((nominellerPreis + lagerkostenProStueck) - (nominellerPreis - (lohnkostenMitErhoehung - rohstoffkosten + lagerkostenProStueck) * (1.0 - 0.45))));
         }
 
         ergebnis = liquiditaetsaenderung;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Fehleranteil zur&uuml;ck
      *
      * @param	qualitaetssicherungNominal	Die nominalen QSAufwendungen gem&auml;ß Unternehmensentscheidung
      * @param	qualitaetssicherungTabelle	Die ArrayList Tabelle mit den Zuordnungen QSAufwendungen - Fehlerrate - Ausschussrate
      * @return	Der Fehleranteil
      */
     public static final double fehleranteil(final double qualitaetssicherungNominal, final ArrayList qualitaetssicherungTabelle)
     {
         double ergebnis = 0.0;
 
         double differenz = 0.0;
         double intervall = 0.0;
         double intervall2 = 0.0;
 
         int groesseQualitaetssicherungTabelle = qualitaetssicherungTabelle.size();
 
         if (qualitaetssicherungNominal <= ((Qualitaetssicherung) qualitaetssicherungTabelle.get(0)).getQualitaetssicherungsausgaben())
             ergebnis = ((Qualitaetssicherung) qualitaetssicherungTabelle.get(0)).getFehlerrate();
         else if (qualitaetssicherungNominal >= ((Qualitaetssicherung) qualitaetssicherungTabelle.get(groesseQualitaetssicherungTabelle - 1)).getQualitaetssicherungsausgaben())
             ergebnis = ((Qualitaetssicherung) qualitaetssicherungTabelle.get(groesseQualitaetssicherungTabelle - 1)).getFehlerrate();
 
         for (int i = 0; i < groesseQualitaetssicherungTabelle - 1; i++)
         {
             // suche das entsprechende Intervall
             if ((((Qualitaetssicherung) qualitaetssicherungTabelle.get(i + 1)).getQualitaetssicherungsausgaben() > qualitaetssicherungNominal) && (qualitaetssicherungNominal >= ((Qualitaetssicherung) qualitaetssicherungTabelle.get(i)).getQualitaetssicherungsausgaben()))
             {
                 differenz = (qualitaetssicherungNominal - ((Qualitaetssicherung) qualitaetssicherungTabelle.get(i + 1)).getQualitaetssicherungsausgaben());
                 intervall = (((Qualitaetssicherung) qualitaetssicherungTabelle.get(i)).getQualitaetssicherungsausgaben() - ((Qualitaetssicherung) qualitaetssicherungTabelle.get(i + 1)).getQualitaetssicherungsausgaben());
                 intervall2 = (((Qualitaetssicherung) qualitaetssicherungTabelle.get(i + 1)).getFehlerrate() - ((Qualitaetssicherung) qualitaetssicherungTabelle.get(i)).getFehlerrate());
 
                 // Interpolation
                 ergebnis = ((Qualitaetssicherung) qualitaetssicherungTabelle.get(i + 1)).getFehlerrate() - (intervall2 * (differenz / intervall));
             }
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Abschreibungskosten zur&uuml;ck
      * Tabelle 21 (29)
      *
      * @param	anlagevermoegenVorquartal	Die H&ouml;he des Anlageverm&ouml;gens im Vorquartal
      * @param	wertberichtigung	Die H&ouml;he der Wertberichtigung
      * @return	Die Abschreibungskosten
      */
     public static final double abschreibungskosten(final double anlagevermoegenVorquartal, final double wertberichtigung)
     {
         double ergebnis = (anlagevermoegenVorquartal * wertberichtigung);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Anlagenprojektierungskosten zur&uuml;ck
      * Beschaffung und Produktion Tabelle 21 Zeile 31 => Anlagenprojektierung == 0.04
      *
      * @param	investition	Die Investitionen
      * @param	anlagenprojektierung	Der Anlagenprojektierungskostensatz (Prozent)
      * @return	Die Anlagenprojektierungskosten
      */
     public static final double anlagenProjektierungsKosten(final double investition, final double anlagenprojektierung)
     {
         double ergebnis = (investition * anlagenprojektierung);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Rohstoff-Verbrauchskosten zur&uuml;ck
      * Beschaffung und Produktion Tabelle 21 Zeile 32
      *
      * @param	nominalProduktionsmenge	Die nominale Produktionsmenge
      * @param	rohstoffVerbrauchProFertigprodukt	Der Rohstoffverbrauch pro Fertigprodukt
      * @param	rohstoffPreisVorquartal	Der Rohstoffpreis im Vorquartal
      * @return	Die Rohstoff-Verbrauchskosten
      */
     public static final double rohstoffVerbrauchsKosten(final double nominalProduktionsmenge, final double rohstoffVerbrauchProFertigprodukt, final double rohstoffPreisVorquartal)
     {
         double ergebnis = (nominalProduktionsmenge * rohstoffVerbrauchProFertigprodukt * rohstoffPreisVorquartal);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Rohstofflagerkosten zur&uuml;ck
      * Beschaffung und Produktion Tabelle 21 Zeile 34
      *
      * @param	rohstoffLagerBestandStueck	Der Rohstofflagerbestand in St&uuml;ck
      * @param	rohstoffLagerKostenProStueck
      * @return	Die Rohstofflagerkosten
      */
     public static final double rohstoffLagerKosten(final double rohstoffLagerBestandStueck, final double rohstoffLagerKostenProStueck)
     {
         double ergebnis = (rohstoffLagerBestandStueck * rohstoffLagerKostenProStueck);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Rohstoff-Bestellungskosten zur&uuml;ck
      * Tabelle 21 (33)
      *
      * @param	normalBestellungskosten	Die Bestellkosten f&uuml;r die normale Rohstoffbestellung
      * @param	expressBestellungskosten	Die Bestellkosten f&uuml;r die express Rohstoffbestellung
      * @param	inflationsindex	Der Inflationsindex
      * @return	Die Rohstoff-Bestellungskosten
      */
     public static final double rohstoffBestellungskosten(final double normalBestellungskosten, final double expressBestellungskosten, final double inflationsindex)
     {
         double ergebnis = ((normalBestellungskosten + expressBestellungskosten) * inflationsindex);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Fertigungszeit pro gutes St&uuml;ck zur&uuml;ck
      * Tabelle 20 (331)  => Fertigungszeit in Minuten pro "gutes" St&uuml;ck
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	nachbearbeiteteProduktionsmenge	Die nachbearbeitete Produktionsmenge
      * @param	guteProduktionsmenge	Die gute Produktionsmenge
      * @param	nominaleFertigungsZeit	Die nominale Fertigungszeit
      * @param	nacharbeitsAufwand	Der Nacharbeitsaufwand (Prozent)
      * @return	Die Fertigungszeit pro gutes St&uuml;ck
      */
     public static final double fertigungsZeitGutesStueck(final double nominaleProduktionsmenge, final double nachbearbeiteteProduktionsmenge, final double guteProduktionsmenge, final double nominaleFertigungsZeit, final double nacharbeitsAufwand)
     {
         double ergebnis = 0.0;
 
         if (guteProduktionsmenge > 0)
             ergebnis = (((nominaleProduktionsmenge * nominaleFertigungsZeit) + (nachbearbeiteteProduktionsmenge * nominaleFertigungsZeit * nacharbeitsAufwand)) / guteProduktionsmenge);
         else
             ergebnis = (((nominaleProduktionsmenge * nominaleFertigungsZeit) + (nachbearbeiteteProduktionsmenge * nominaleFertigungsZeit * nacharbeitsAufwand)));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die gesamte Fertigungszeit zur&uuml;ck
      * Fertigungszeit in Stunden insgesamt
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	nachbearbeiteteProduktionsmenge	Die nachbearbeitete Produktionsmenge
      * @param	nominaleFertigungsZeit	Die nominale Fertigungszeit
      * @param	nacharbeitsAufwand	Der Nacharbeitsaufwand (Prozent)
      * @return	Die gesamte Fertigungszeit
      */
     public static final double fertigungszeitGesamt(final double nominaleProduktionsmenge, final double nachbearbeiteteProduktionsmenge, final double nominaleFertigungsZeit, final double nacharbeitsAufwand)
     {
         double ergebnis = (((nominaleProduktionsmenge * nominaleFertigungsZeit) + (nachbearbeiteteProduktionsmenge * nominaleFertigungsZeit * nacharbeitsAufwand)) / 60.0);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Kapazit&auml;tsauslastung zur&uuml;ck
      * Tabelle 20 (332)  => R&uuml;ckgabe in Prozent ; Berechnung des 2. &uuml;bergabeparameter erfolgt im Vorquartal f&uuml;r das aktuelle
      *
      * @param	fertigungszeitGesamt	Die gesamte Fertigungszeit
      * @param	kapazitaetsbestandVorquartal	Der Kapazit&auml;tsbestand in Stunden
      * @return	Die Kapazit&auml;tsauslastung
      */
     public static final double kapazitaetsauslastung(final double fertigungszeitGesamt, final double kapazitaetsbestandVorquartal)
     {
         double ergebnis = 0.0;
 
         if (kapazitaetsbestandVorquartal > 0)
             ergebnis = ((double) fertigungszeitGesamt / (double) kapazitaetsbestandVorquartal);
         else
             ergebnis = ((double) fertigungszeitGesamt);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Kapazit&auml;tsbestand im Folgequartal zur&uuml;ck
      * Tabelle 20 (333)
      *
      * @param	kapazitaetsbestand	Der Kapazit&auml;tsbestand dieses Quartal
      * @param	investitionen	Die investitionen
      * @param	abschreibungskosten	Die Abschreibungskosten
      * @param	spezifischeInvestionsausgaben	Die spezifischen Investitionsausgaben
      * @return	Der Kapazit&auml;tsbestand im Folgequartal
      */
     public static final double kapazitaetsbestandFolgequartal(final double kapazitaetsbestand, final double investitionen, final double abschreibungskosten, final double spezifischeInvestionsausgaben)
     {
         double ergebnis = 0.0;
 
         if (spezifischeInvestionsausgaben > 0)
             ergebnis = (kapazitaetsbestand + ((investitionen + abschreibungskosten) / spezifischeInvestionsausgaben));
         else
             ergebnis = (kapazitaetsbestand + (investitionen + abschreibungskosten));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Ausschusskosten zur&uuml;ck
      * Wird f&uuml;r die Qualit&auml;tskosten ben&ouml;tigt
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	ausschuss	Die Ausschussquote
      * @param	fertigungsstueckzeit	Die Fertigungszeit pro St&uuml;ck
      * @param	lohnkosten	Die Lohnkosten pro St&uuml;ck
      * @param	lohnindex	Der Lohnerh&ouml;hungsindex
      * @param	rohstoffverbrauch	Der Rohstoffverbrauch pro St&uuml;ck
      * @param	rohstoffwert	Der Rohstoffwert
      * @param	kapazitaetsauslastung	Die Kapazit&auml;tsauslastung
      * @return	Die Ausschusskosten
      */
     public static final double ausschusskosten(final double nominaleProduktionsmenge, final double ausschuss, final double fertigungsstueckzeit, final double lohnkosten, final double lohnindex, final double rohstoffverbrauch, final double rohstoffwert, final double kapazitaetsauslastung)
     {
         double ergebnis = 0.0;
 
         double sektor = 0.0;
         double rest = 0.0;
 
         if (kapazitaetsauslastung < 100)
         {
             ergebnis = ((nominaleProduktionsmenge * ausschuss) * ((fertigungsstueckzeit / 60.0 * lohnkosten * lohnindex) + rohstoffverbrauch * rohstoffwert));
         }
         else
         {
             sektor = kapazitaetsauslastung / 50.0;
             rest = sektor % 1;
             sektor = sektor - rest;
 
             if (sektor % 2 != 0)
                 ergebnis = ((nominaleProduktionsmenge * ausschuss) * ((fertigungsstueckzeit / 60 * lohnkosten * lohnindex) + rohstoffverbrauch * rohstoffwert));
             else if (sektor % 2 == 0)
                 ergebnis = ((nominaleProduktionsmenge * ausschuss) * ((fertigungsstueckzeit / 60 * lohnkosten * lohnindex * 1.5) + rohstoffverbrauch * rohstoffwert));
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Fehlerkosten zur&uuml;ck
      * Wird f&uuml;r die Qualit&auml;tskosten ben&ouml;tigt
      *
      * @param	ausschusskosten	Die Ausschusskosten
      * @param	nacharbeitslohnkosten	Die Nacharbeitslohnkosten
      * @return	Die Fehlerkosten
      */
     public static final double fehlerkosten(final double ausschusskosten, final double nacharbeitslohnkosten)
     {
         double ergebnis = (ausschusskosten + nacharbeitslohnkosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Qualit&auml;tskosten zur&uuml;ck
      * Tabelle 20 (341)
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	inflationsindex	Der Inflationsindex
      * @param	qualitaetssicherungProStueckReal	Die reale Qualit&auml;tsssicherung pro St&uuml;ck
      * @param	fehlerkosten	Die Fehlerkosten
      * @return	Die Qualit&auml;tskosten
      */
     public static final double qualitaetskosten(final double nominaleProduktionsmenge, final double inflationsindex, final double qualitaetssicherungProStueckReal, final double fehlerkosten)
     {
         double ergebnis = ((nominaleProduktionsmenge * (qualitaetssicherungProStueckReal * inflationsindex)) + fehlerkosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Nacharbeits-Lohnkosten zur&uuml;ck
      * Tabelle 20 (342)
      *
      * @param	fertigungszeit	Die Fertigungszeit pro St&uuml;ck
      * @param	stundenlohn	Der Stundelohn
      * @param	ueberstundenZuschlag	Der &Uuml;berstundenzuschlag
      * @param	nacharbeitsAufwand	Der Nacharbeitsaufwand
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	fehleranteil	Der Fehleranteil
      * @return	Die Nacharbeits-Lohnkosten
      */
     public static final double nacharbeitskosten(final double fertigungszeit, final double stundenlohn, final double ueberstundenZuschlag, final double nacharbeitsAufwand, final double nominaleProduktionsmenge, final double fehleranteil)
     {
         double ergebnis = 0.0;
 
         double stuecklohn = 0.0;
         double stuecklohnueberstunde = 0.0;
         double nacharbeitskosten = 0.0;
 
         stuecklohn = (fertigungszeit / 60.0) * stundenlohn;
         stuecklohnueberstunde = stuecklohn * ueberstundenZuschlag;
         nacharbeitskosten = (stuecklohn + stuecklohnueberstunde) * nacharbeitsAufwand;
 
         ergebnis = ((nominaleProduktionsmenge * fehleranteil * nacharbeitskosten * 0.75));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Ausschussquote (25% von der Fehlerrate) zur&uuml;ck
      * Ausschuss in Prozent
      *
      * @param	fehleranteil	Der Fehleranteil
      * @return	Die Ausschussquote
      */
     public static final double ausschuss(final double fehleranteil)
     {
         double ergebnis = (fehleranteil * 0.25);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die reale Qualt&auml;tssicherung zur&uuml;ck
      * Tabelle A1.1 Zeile 2.33 und Tabelle A1.2 Zeile 3.4
      *
      * @param	qualitaetskostenNominalProStueck	Qualt&auml;tskosten pro nominal produziertes St&uuml;ck
      * @param	inflationsindex	Der Inflationsindex
      * @return	Die reale Qualt&auml;tssicherung
      */
     public static final double qualtaetssicherungReal(final double qualitaetskostenNominalProStueck, final double inflationsindex)
     {
         double ergebnis = 0.0;
 
         if (inflationsindex > 0)
             ergebnis = (qualitaetskostenNominalProStueck / inflationsindex);
         else
             ergebnis = 0.0;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die nominale Produktionsmenge zur&uuml;ck
      * Tabelle 20 (311)
      *
      * @param	guteProduktionsmenge	Die gute Produktionsmenge
      * @param	ausschuss	Die Ausschussquote
      * @return	Die nominale Produktionsmenge
      */
     public static final double produktionsmengeNominal(final double guteProduktionsmenge, final double ausschuss)
     {
         double ausschussTemp = ausschuss / Konstanten.HUNDRED_PERCENT;
 
         double ergebnis = (guteProduktionsmenge / (1 - ausschussTemp));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die nacharbeitbare Produktionsmenge zur&uuml;ck
      * Tabelle 20 (313)
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	fehleranteil	Der Fehleranteil
      * @return	Die nacharbeitbare Produktionsmenge
      */
     public static final double produktionsmengeNacharbeitbar(final double nominaleProduktionsmenge, final double fehleranteil)
     {
         double fehleranteilTemp = fehleranteil / Konstanten.HUNDRED_PERCENT;
 
         double ergebnis = (nominaleProduktionsmenge * fehleranteilTemp * 0.75);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Ausschuss-Produktionsmenge zur&uuml;ck
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	ausschuss	Der Ausschussanteil
      * @return	Die Ausschuss-Produktionsmenge
      */
     public static final double produktionsmengeAusschuss(final double nominaleProduktionsmenge, final double ausschuss)
     {
         double ausschussTemp = ausschuss / Konstanten.HUNDRED_PERCENT;
 
         double ergebnis = (nominaleProduktionsmenge * ausschussTemp);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die fehlerhafte Produktionsmenge zur&uuml;ck
      * Tabelle 20 Z.:312
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	fehleranteil	Der Fehleranteil
      * @return	Die fehlerhafte Produktionsmenge
      */
     public static final double produktionsmengeFehlerhaft(final double nominaleProduktionsmenge, final double fehleranteil)
     {
         double fehleranteilTemp = fehleranteil / Konstanten.HUNDRED_PERCENT;
 
         double ergebnis = (nominaleProduktionsmenge * fehleranteilTemp);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Aufarbeitungskosten zur&uuml;ck
      * Tabelle21 Zeile 24
      *
      * @param	lagerbestandFertigprodukteVorquartal	Der Lagerbestand an Fertigprodukten im Vorquartal
      * @param	produktartaenderungInStufen	Die Produktart&auml;nderung in Stufen
      * @return	Die Aufarbeitungskosten
      */
     public static final double aufarbeitungskosten(final double lagerbestandFertigprodukteVorquartal, final int produktartaenderungInStufen)
     {
         double ergebnis = (lagerbestandFertigprodukteVorquartal * produktartaenderungInStufen * 0.75);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die gesamten Qualit&auml;tssicherungsaufwendungen zur&uuml;ck
      * Tabelle: 21 Z.: 25
      * qualitaetssicherungskostenNominalProStueck aus dem Entscheidungsblatt
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	qualitaetssicherungskostenNominalProStueck	Die nominale pro St&uuml;ck aufgewendeten Qualit&auml;tssicherungskosten
      * @return	Die gesamten Qualit&auml;tssicherungsaufwendungen
      */
     public static final double qualitaetssicherungGesamt(final double nominaleProduktionsmenge, final double qualitaetssicherungskostenNominalProStueck)
     {
         double ergebnis = (nominaleProduktionsmenge * qualitaetssicherungskostenNominalProStueck);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Fertigungs-Lohnkosten zur&uuml;ck
      * Tabelle 20 (26)
      *
      * @param	nominaleProduktionsmenge	Die nominale Produktionsmenge
      * @param	fertigungszeitNominal	Die nominale Fertigungszeit pro St&uuml;ck
      * @param	lohnkostenMitErhoehung	Die Lohnkosten mit Erh&ouml;hung
      * @param	nacharbeitsAufwand	Der Nacharbeitsaufwand
      * @param	fehleranteil	Der Fehleranteil
      * @return     Die Fertigungs-Lohnkosten
      */
     public static final double fertigungsLohnKosten(final double nominaleProduktionsmenge, final double fertigungszeitNominal, final double lohnkostenMitErhoehung, final double nacharbeitsAufwand, final double fehleranteil)
     {
         double ergebnis = (nominaleProduktionsmenge * (fertigungszeitNominal / 60) * lohnkostenMitErhoehung * (1.0 + fehleranteil * 0.75 * nacharbeitsAufwand));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die &Uuml;berstundenzuschl&auml;ge zur&uuml;ck
      * Tabelle 20 (27)
      *
      * @param	kapazitaetsauslastung    Die Kapazit&auml;tsauslastung
      * @param	fertigungszeitGesamt  Die gesamte Fertigungszeit
      * @param	kapazitaetsbestandFolgeQuartalVorquartal Der Kapazit&auml;tsbestand im Folgequartal
      * @param	lohnkostenMitErhoehung   Lohnkosten mit Erh&ouml;hung
      * @return	Die &Uuml;berstundenzuschl&auml;ge
      */
     public static final double ueberstundenzuschlaege(final double kapazitaetsauslastung, final double fertigungszeitGesamt, final double kapazitaetsbestandFolgeQuartalVorquartal, final double lohnkostenMitErhoehung)
     {
         double ergebnis = 0.0;
         /***@TODO An nach oben offene Verh&auml;ltnisse anpassen*/
 
         if (((kapazitaetsauslastung / Konstanten.HUNDRED_PERCENT) > 1.0) && ((kapazitaetsauslastung / Konstanten.HUNDRED_PERCENT) <= 1.5))
         {
             ergebnis = ((fertigungszeitGesamt - (kapazitaetsbestandFolgeQuartalVorquartal * 1.0)) * lohnkostenMitErhoehung * 0.5);
         }
         else if (((kapazitaetsauslastung / Konstanten.HUNDRED_PERCENT) > 2.0) && ((kapazitaetsauslastung / Konstanten.HUNDRED_PERCENT) <= 2.5))
         {
             ergebnis = ((fertigungszeitGesamt - (kapazitaetsbestandFolgeQuartalVorquartal * 2.0)) * lohnkostenMitErhoehung * 0.5);
         }
         else
         {
             ergebnis = 0.0;
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Lohnrate zur&uuml;ck
      * Lohnrate in Prozent
      *
      * @param	lohnindexVorquartal  Der Lohnerh&ouml;hungsindex im Vorquartal
      * @param	lohnrate Die Lohnerh&ouml;hungsrate
      * @return	Die Lohnrate
      */
     public static final double lohnindex(final double lohnindexVorquartal, final double lohnrate)
     {
         double lohnindexVorquartalTemp = lohnindexVorquartal / Konstanten.HUNDRED_PERCENT;
         double lohnrateTemp = lohnrate / Konstanten.HUNDRED_PERCENT;
 
         double ergebnis = (lohnindexVorquartalTemp * (1.0 + lohnrateTemp)) * Konstanten.HUNDRED_PERCENT; // in Prozent
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die nominalen Lohnkosten zur&uuml;ck
      *
      * @param	lohnkosten   Die Lohnkosten
      * @param	lohnindex    Der Lohnerh&ouml;hungsindex
      * @return	Die nominalen Lohnkosten
      */
     public static final double lohnkostenNominal(final double lohnkosten, final double lohnindex)
     {
         double ergebnis = (lohnkosten * lohnindex);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Verwaltungskosten zur&uuml;ck
      * Tabelle: 21 Zeile 41
      *
      * @param	kapazitaetsauslastung    Die Kapazit&auml;tsauslastung
      * @param	lohnindex    Der Lohnerh&ouml;hungsindex
      * @param	verwaltungTabelle    Die Tabelle ArrayList mit den Zuordnungen Verwaltungskosten / Schicht
      * @return	Die Verwaltungskosten
      */
     public static final double verwaltung(final double kapazitaetsauslastung, final double lohnindex, final ArrayList verwaltungTabelle)
     {
         double ergebnis = 0.0;
 
         int groesseVerwaltungTabelle = verwaltungTabelle.size();
 
         for (int i = 0; i < groesseVerwaltungTabelle - 1; i++)
         {
             if (kapazitaetsauslastung >= ((Verwaltungskosten) verwaltungTabelle.get(i)).getKapazitaetsauslastung() && kapazitaetsauslastung < ((Verwaltungskosten) verwaltungTabelle.get(i + 1)).getKapazitaetsauslastung())
             {
                 ergebnis = ((Verwaltungskosten) verwaltungTabelle.get(i + 1)).getKosten() * lohnindex;
                 break;
             }
             else if (kapazitaetsauslastung < ((Verwaltungskosten) verwaltungTabelle.get(i)).getKapazitaetsauslastung())
             {
                 ergebnis = ((Verwaltungskosten) verwaltungTabelle.get(i)).getKosten() * lohnindex;
                 break;
             }
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Schichtwechsel-Kosten zur&uuml;ck
      * Tabelle 21 Zeile 28
      *
      *
      * @param	schichtwechselKosten Die Basis-Schichtwechselkosten
      * @param	kapazitaetsauslastungVorquartal    Die Kapazit&auml;tsauslastung im Vorquartal
      * @param	kapazitaetsauslastung    Die Kapazit&auml;tsauslastung
      * @param	lohnindex    Der Lohnerh&ouml;hungsindex
      * @return	Die Schichtwechsel-Kosten
      */
     public static final double schichtwechsel(final double schichtwechselKosten, final double kapazitaetsauslastungVorquartal, final double kapazitaetsauslastung, final double lohnindex)
     {
         double ergebnis = 0.0;
 
         double wechsel = 0.0;
         double schichtAlt = 0.0;
         double schichtNeu = 0.0;
         double temp = 0.0;
 
         schichtAlt = schicht(kapazitaetsauslastungVorquartal);
         schichtNeu = schicht(kapazitaetsauslastung);
 
         temp = schichtAlt - schichtNeu;
 
         wechsel = Math.abs(temp);
 
         ergebnis = (wechsel * schichtwechselKosten * lohnindex);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die aktuelle Schicht ausgehend von der Kapazit&auml;tsauslastung zur&uuml;ck
      *
      * @param	kapazitaetsauslastung    Die Kapazit&auml;tsauslastung
      * @return	Die aktuelle Schicht
      */
     public static final double schicht(final double kapazitaetsauslastung)
     {
         double ergebnis = 0.0;
 
         double sektor = 0.0;
 
         sektor = kapazitaetsauslastung / 50.0;
         ergebnis = Math.floor((sektor - 1.0) / 2.0);
 
         if (ergebnis < 1.0)
             ergebnis = 1.0;
         else
             ergebnis += 1.0;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Rohstoffverbrauch zur&uuml;ck
      * Tabelle: 20 Zeile 42
      *
      * @param	nominaleProduktionsmenge Die nominale Produktionsmenge
      * @param	rohstoffverbrauchProStueck   Der Rohstoffverbrauch pro St&uuml;ck
      * @return	Der Rohstoffverbrauch
      */
     public static final double rohstoffverbrauch(final double nominaleProduktionsmenge, final double rohstoffverbrauchProStueck)
     {
         double ergebnis = (nominaleProduktionsmenge * rohstoffverbrauchProStueck);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Rohstofflagerbestand zur&uuml;ck
      * Tabelle: 20 Zeile 43
      *
      * @param  rohstoffLagerBestandVorquartal   Der Rohstofflagerbestand im Vorquartal
      * @param  rohstoffverbrauch    Der Rohstoffverbrauch
      * @param  rohstoffBestellmenge Die Rohstoff-Bestellmenge
      * @return Der Rohstofflagerbestand
      */
     public static final double rohstoffLagerBestand(final double rohstoffLagerBestandVorquartal, final double rohstoffverbrauch, final double rohstoffBestellmenge)
     {
         double ergebnis = (rohstoffLagerBestandVorquartal - rohstoffverbrauch + rohstoffBestellmenge);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Rohstoffpreis zur&uuml;ck
      *
      * @param	rohstoffpreisEndeVorquartal   Der Rohstoffpreis im Vorquartal
      * @param	inflationsindex   Der Inflationsindex
      * @return  Der Rohstoffpreis
      */
     public static final double rohstoffpreis(final double rohstoffpreisEndeVorquartal, final double inflationsindex)
     {
         double ergebnis = (rohstoffpreisEndeVorquartal * inflationsindex);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert den Rohstoffwert zur&uuml;ck
      * Tabelle: 20 Zeile 44
      *
      * @param	rohstoffBestellmenge  Die Rohstoffbestellmenge
      * @param	rohstoffLagerVorquartal   Die Rohstofflagermenge im Vorquartal
      * @param	rohstoffverbrauch Der Rohstoffverbrauch
      * @param	rohstoffwertEndeVorquartal    Der Rohstoffwert am Quartalsende
      * @param	rohstoffpreis Der Rohstoffpreis
      * @return  Der Rohstoffwert
      */
     public static final double rohstoffwert(final double rohstoffBestellmenge, final double rohstoffLagerVorquartal, final double rohstoffverbrauch, final double rohstoffwertEndeVorquartal, final double rohstoffpreis)
     {
         double ergebnis = 0.0;
 
         if ((rohstoffLagerVorquartal - rohstoffverbrauch) > 0 && (rohstoffBestellmenge + rohstoffLagerVorquartal - rohstoffverbrauch) > 0)
             ergebnis = (rohstoffwertEndeVorquartal * (rohstoffLagerVorquartal - rohstoffverbrauch) + rohstoffpreis * rohstoffBestellmenge) / (rohstoffBestellmenge + rohstoffLagerVorquartal - rohstoffverbrauch);
         else
             ergebnis = (rohstoffpreis);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die gesamte Fertigungszeit der Fertigungs-Lohnkosten zur&uuml;ck
      * f&uuml;r die neue Berechnung der Fertigungslohnkosten relevant
      *
      * @param	nominaleProduktionsmenge  Die nominale Produktionsmenge
      * @param	fertigungsstueckzeit    Die Fertigungszeit pro St&uuml;ck
      * @param	produktionsmengeNacharbeit    Die Produktionsmenge in der Nacharbeitszeit
      * @return  Die gesamte Fertigungszeit der Fertigungs-Lohnkosten
      */
     public static final double fertigungszeitGesamtFertigungsLohnKosten(final double nominaleProduktionsmenge, final double fertigungsstueckzeit, final double produktionsmengeNacharbeit)
     {
         double ergebnis = ((nominaleProduktionsmenge * fertigungsstueckzeit + produktionsmengeNacharbeit * fertigungsstueckzeit * 1.3) / 60.0);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die normale Kapazit&auml;t zur&uuml;ck
      * Unter Ber&uuml;cksichtigung der gesamten Fertigungszeit
      * Der Kapazit&auml;tsbestand wird im Vorquartal f&uuml;r das aktuelle berechnet
      * dass heisst 2te Schicht => die Normalkapazit&auml;t ist doppelt so hoch wie die Kapazitaetsauslastung bei 100%
      * dass heisst 3te Schicht => die Normalkapazit&auml;t ist dreimal so hoch wie die Kapazitaetsauslastung bei 100%
      *
      * @param	kapazitaetsauslastung    Die Kapazit&auml;tsauslastung
      * @param	kapazitaetsbestandVorquartal    Die Kapazit&auml;tsauslastung im Vorquartal
      * @return  Die normale Kapazit&auml;t
      */
     public static final double normalkapazitaet(final double kapazitaetsauslastung, final double kapazitaetsbestandVorquartal)
     {
         double ergebnis = 0.0;
 
         double sektor = 0.0;
 
         sektor = kapazitaetsauslastung / 50.0;
         ergebnis = Math.floor((sektor - 1.0) / 2.0);
 
         if (ergebnis < 1.0)
             ergebnis = 1.0;
         else
             ergebnis += 1.0;
 
         ergebnis *= kapazitaetsbestandVorquartal;
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Fertigungszeit ohne &Uuml;berstunden und ohne Nacharbeit zur&uuml;ck
      * Fertigungszeit  ohne Nacharbeit und ohne &uuml;berstunden
      *
      * @param	nominaleProduktionsmenge  Die nominale Produktionsmenge
      * @param	fertigungsstueckZeit    Die Fertigungszeit pro St&uuml;ck
      * @return  Die Fertigungszeit ohne &Uuml;berstunden und ohne Nacharbeit
      */
     public static final double fertigungszeitOhneUeberstundenOhneNacharbeit(final double nominaleProduktionsmenge, final double fertigungsstueckZeit)
     {
         double ergebnis = (nominaleProduktionsmenge * fertigungsstueckZeit / 60.0);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Fertigungs-Lohnkosten ohne &Uuml;berstunden und ohne Nacharbeit zur&uuml;ck
      * Tabelle 21 Zeile 261
      * Fertigungslohnkosten ohne &uuml;berstunden und ohne Nacharbeit
      *
      * @param	fertigungszeitOhneUeberstundenOhneNacharbeit    Die Fertigungszeit ohne &Uuml;berstunden und ohne Nacharbeit
      * @param	lohnkosten    Die Lohnkosten
      * @return  Die Fertigungs-Lohnkosten ohne &Uuml;berstunden und ohne Nacharbeit
      */
     public static final double fertigungsLohnKostenOhneUeberstundenOhneNacharbeit(final double fertigungszeitOhneUeberstundenOhneNacharbeit, final double lohnkosten)
     {
         double ergebnis = (fertigungszeitOhneUeberstundenOhneNacharbeit * lohnkosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die &Uuml;berstundenzuschl&auml;ge der Fertigungs-Lohnkosten zur&uuml;ck
      * Tabelle 21 Zeile 262
      * anteilige &uuml;berstundenzuschl&auml;ge f&uuml;r die Fertigungslohnkosten ohne Nacharbeit
      * bei den Lohnkosten sind die aufgelaufenen Lohnerh&ouml;hungen / -erniedrigungen zu ber&uuml;cksichtigen
      *
      * @param	fertigungszeitOhneUeberstundenOhneNacharbeit   Die Fertigungszeit ohne &Uuml;berstunden und ohne Nacharbeit
      * @param	normalkapazitaet  Die normale Kapazit&auml;t
      * @param	lohnkosten    Die Lohnkosten
      * @return  Die &Uuml;berstundenzuschl&auml;ge der Fertigungs-Lohnkosten
      */
     public static final double ueberstundenzuschlaegeFertigungsLohnKosten(final double fertigungszeitOhneUeberstundenOhneNacharbeit, final double normalkapazitaet, final double lohnkosten)
     {
         double ergebnis = 0.0;
         double sektor = 0.0;
 
         if (normalkapazitaet > 0)
             sektor = (fertigungszeitOhneUeberstundenOhneNacharbeit / (normalkapazitaet / 2.0));
         else
             sektor = 0.0;
 
         sektor = Math.ceil((sektor));
 
         if (sektor < 2.0 || sektor % 2.0 == 0)
             ergebnis = 0.0;
         else
             ergebnis = ((fertigungszeitOhneUeberstundenOhneNacharbeit - (((sektor - 1.0) / 2.0) * normalkapazitaet)) * 0.5 * lohnkosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Nacharbeitszeit ohne &Uuml;berstunden zur&uuml;ck
      * Nacharbeitszeit ohne &uuml;berstunden
      * Formel: PM-nom * Fehler[in Prozent] * 0.75 * 1.3(Mehraufwand) * FZ/60
      *
      * @param	produktionsmengeNacharbeit    Die Produktionsmenge in Nahcarbeit
      * @param	fertigungsstueckzeit    Die Fertigungszeit pro St&uuml;ck
      * @param	nacharbeitsaufwand    Der Nacharbeitsaufwand
      * @return  Die Nacharbeitszeit ohne &Uuml;berstunden
      */
     public static final double nacharbeitsZeitOhneUeberstunden(final double produktionsmengeNacharbeit, final double fertigungsstueckzeit, final double nacharbeitsaufwand)
     {
         double ergebnis = (produktionsmengeNacharbeit * (fertigungsstueckzeit / 60.0) * (1.0 + nacharbeitsaufwand));
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Nacharbeits-Lohnkosten ohne &Uuml;berstunden zur&uuml;ck
      * Tabelle 21 Zeile 263
      * Nacharbeitslohnkosten ohne &uuml;berstunden
      * Formel: PM-nom * Fehler[in Prozent] * 0.75 * 1.3(Mehraufwand) * FZ/60 * LK[10 EURO/h]
      * bei den Lohnkosten sind die aufgelaufenen Lohnerh&ouml;hungen / -erniedrigungen zu ber&uuml;cksichtigen
      *
      * @param	nacharbeitsZeitOhneUeberstunden   Die Nacharbeitszeit ohne &Uuml;berstunden
      * @param	lohnkosten    Die Lohnkosten
      * @return  Die Nacharbeits-Lohnkosten ohne &Uuml;berstunden
      */
     public static final double nacharbeitslohnkostenOhneUeberstunden(final double nacharbeitsZeitOhneUeberstunden, final double lohnkosten)
     {
         double ergebnis = (nacharbeitsZeitOhneUeberstunden * lohnkosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die &Uuml;berstundenzuschl&auml;ge auf die Nacharbeit zur&uuml;ck
      * Tabelle 21 Zeile 264
      * anteilige &uuml;berstundenzuschl&auml;ge f&uuml;r die Nacharbeit
      * 1. Fall: die gesamte Fertigungszeit ist kleiner als die Normalkapazitaet => keine &uuml;berstunden f&uuml;r die Nacharbeit
      * 2. Fall: die Fertigungszeit ohne Nacharbeit ist gr&ouml;ßer als die Normalkapazit&auml;t => gesamte Nacharbeit ist in &uuml;berstunden
      * 3. Fall: die gesamte Fertigungszeit ist gr&ouml;ßer als die Normalkapazit&auml;t => ein Teil der Nacharbeit ist in &uuml;berstunden
      * bei den Lohnkosten sind die aufgelaufenen Lohnerh&ouml;hungen / -erniedrigungen zu ber&uuml;cksichtigen
      *
      * @param	nacharbeitslohnkostenOhneUeberstunden Die Nacharbeits-Lohnkosten ohne &Uuml;berstunden
      * @param	fertigungszeitGesamt    Die gesamte Fertigungszeit
      * @param	fertigungszeitOhneUeberstundenOhneNacharbeit   Die Fertigungszeit ohne &Uuml;berstunden und ohne Nacharbeit
      * @param	nacharbeitsZeitOhneUeberstunden   Die Nacharbeitszeit ohne &Uuml;berstunden
      * @param	normalkapazitaet  Die Normalkapazit&auml;t
      * @param	lohnkosten    Die Lohnkosten
      * @return  Die &Uuml;berstundenzuschl&auml;ge auf die Nacharbeit
      */
     public static final double ueberstundenzuschlagNacharbeit(final double nacharbeitslohnkostenOhneUeberstunden, final double fertigungszeitGesamt, final double fertigungszeitOhneUeberstundenOhneNacharbeit, final double nacharbeitsZeitOhneUeberstunden, final double normalkapazitaet, final double lohnkosten)
     {
         double ergebnis = 0.0;
         /***@TODO An nach oben offene Verh&auml;ltnisse anpassen*/
 
         double temp;
 
         if (fertigungszeitGesamt <= normalkapazitaet)
             return 0;
         else if (fertigungszeitGesamt > (1.5 * normalkapazitaet) && fertigungszeitGesamt <= (2 * normalkapazitaet))
             return 0;
         else if (fertigungszeitGesamt > (2.5 * normalkapazitaet) && fertigungszeitGesamt <= (3 * normalkapazitaet))
             return 0;
         else if (fertigungszeitGesamt > (3.5 * normalkapazitaet) && fertigungszeitGesamt <= (4 * normalkapazitaet))
             return 0;
         else if (fertigungszeitGesamt > normalkapazitaet && fertigungszeitGesamt <= (1.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit > normalkapazitaet)
             return (nacharbeitslohnkostenOhneUeberstunden / 2);
         else if (fertigungszeitGesamt > (2 * normalkapazitaet) && fertigungszeitGesamt <= (2.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit > (2 * normalkapazitaet))
             return (nacharbeitslohnkostenOhneUeberstunden / 2);
         else if (fertigungszeitGesamt > (3 * normalkapazitaet) && fertigungszeitGesamt <= (3.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit > (3 * normalkapazitaet))
             return (nacharbeitslohnkostenOhneUeberstunden / 2);
         else if (fertigungszeitGesamt > normalkapazitaet && fertigungszeitGesamt <= (1.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit < normalkapazitaet)
         {
             temp = (nacharbeitsZeitOhneUeberstunden - (normalkapazitaet - fertigungszeitOhneUeberstundenOhneNacharbeit));
             return (temp * lohnkosten / 2);
         }
         else if (fertigungszeitGesamt > (2 * normalkapazitaet) && fertigungszeitGesamt <= (2.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit < (2 * normalkapazitaet))
         {
             temp = (nacharbeitsZeitOhneUeberstunden - (normalkapazitaet - fertigungszeitOhneUeberstundenOhneNacharbeit));
             return (temp * lohnkosten / 2);
         }
         else if (fertigungszeitGesamt > (3 * normalkapazitaet) && fertigungszeitGesamt <= (3.5 * normalkapazitaet) && fertigungszeitOhneUeberstundenOhneNacharbeit < (3 * normalkapazitaet))
         {
             temp = (nacharbeitsZeitOhneUeberstunden - (normalkapazitaet - fertigungszeitOhneUeberstundenOhneNacharbeit));
             return (temp * lohnkosten / 2);
         }
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die Lohnkosten zur&uuml;ck
      * Tabelle 20 Zeile 342
      *
      * @param	nacharbeitslohnkostenOhneUeberstunden Die Nacharbeits-Lohnkosten ohne &Uuml;berstunden
      * @param	ueberstundenzuschlagNacharbeit    Die &Uuml;berstundenzuschl&auml;ge auf die Nacharbeit
      * @return  Die Lohnkosten
      */
     public static final double lohnkosten(final double nacharbeitslohnkostenOhneUeberstunden, final double ueberstundenzuschlagNacharbeit)
     {
         double ergebnis = (nacharbeitslohnkostenOhneUeberstunden + ueberstundenzuschlagNacharbeit);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 
     /***
      * Liefert die gesamten Fertigungs-Lohnkosten zur&uuml;ck
      *
      * @param	ueberstundenzuschlagNacharbeit    Die &Uuml;berstundenzuschl&auml;ge auf die Nacharbeit
      * @param	nacharbeitslohnkostenOhneUeberstunden Die Nacharbeits-Lohnkosten ohne &Uuml;berstunden
      * @param	fertigungsLohnKostenOhneUeberstundenOhneNacharbeit   Die Fertigungslohnkosten ohne &Uuml;berstunden und ohne Nacharbeit
      * @param	ueberstundenzuschlaegeFertigungsLohnKosten   Die &Uuml;berstundenzuschl&auml;ge der Fertigungs-Lohnkosten
      * @return  Die gesamten Fertigungs-Lohnkosten
      */
     public static final double fertigungsLohnKostenGesamt(final double ueberstundenzuschlagNacharbeit, final double nacharbeitslohnkostenOhneUeberstunden, final double fertigungsLohnKostenOhneUeberstundenOhneNacharbeit, final double ueberstundenzuschlaegeFertigungsLohnKosten)
     {
         double ergebnis = (ueberstundenzuschlagNacharbeit + nacharbeitslohnkostenOhneUeberstunden + fertigungsLohnKostenOhneUeberstundenOhneNacharbeit + ueberstundenzuschlaegeFertigungsLohnKosten);
 
         // Einfache double Operationen produzieren nicht immer korrekt Ergebnisse - Rundung auf 10 Nachkommastellen
         double rueckgabewert = Common.aufZehnNachkommastellenRunden(ergebnis);
 
         return rueckgabewert;
     }
 }