/*
================================================================================
= Autor:        Mario SCHNEPF
= MatrklNr:     e0225056
= E-Mail:       ma_s@gmx.at / e0225056@student.tuwien.ac.at
= Datum:        15. Jänner 2003
================================================================================
= private void Input()
=   liest einen String ein und speichert diesen im String "Eingabe"
= ------------------------------------------------------------------------------
= private void doTeilstringsErzeugen() throws EprogException
=   diese Methode splittet den String "Eingabe" in jene Teilstrings auf die
=   entweder durch "+" oder "-" getrennt sind, wobei "+" bzw. "-" zum 2.ten Teil
=   kommt.
=   Beispiel: "aaa+bbb-ccc"  ==>  "aaa"   "+bbb"    "-ccc"
=   die Teilstrings werden in der "TeilString"-Hashtable abgespeichert
= ------------------------------------------------------------------------------
= private void erzeugeTerme() throws EprogException
=   die in der "TeilString"-Hashtable abgespeicherten Strings werden versucht in
=   Terme umzuwandeln wobei diese gleich auf syntaktische-Korrektheit überprüft
=   werde - die umgewandelten Terme werden in der "Terme"-Hashtable abgeseichert
=   zusätzlich wird in der "Art"-Hashtable an der gleichen Stelle (mit dem
=   gleichen Index wie "Terme") ein String abgespeichert der anzeigt um welche
=   Art von Objekt (sincos, euler, zahl) es sich an genau dieser Stelle in der
=   "Terme"-Hashtable handelt
= ------------------------------------------------------------------------------
= private void doAbleiten() throws EprogException
=   die in "Terme" abgespeicherten Terme werden der Reihe nach ausgelesen und
=   einzeln abgeleitet (es wird für das jeweilige Unter-Objekt die entsprechende
=   Methode "doAbleitung" aufgerufen
= ------------------------------------------------------------------------------
= private void doVereinfachen() throws EprogException
=   die in "Terme" abgespeicherten Terme werden paarweise miteinander verglichen
=   sollte man zwei zusammenfassen können, so wird dieser an die erste Stelle
=   vorgezogen und der zweite Term wird "gelöscht" in dem alle Werte auf "0" bzw
=   auf "" gesetzt werden
= ------------------------------------------------------------------------------
= private void printAusgabe()
=   für alle "Terme" wird die entsprechende Methode "erzeugeString" aufgerufen
=   und so der "Ausgabe"-String zusammengestückelt. Anschließend wird dieser
=   String ausgegeben.
================================================================================
*/

package symbdiff;

// Packages importieren
import eprog.*;
import java.util.Hashtable;
import Main;


public class symbdiff
{
  // ANFANG: Variablen deklarieren =============================================
  private String Eingabe = new String();
  private Hashtable TeilString = new Hashtable();
  private Hashtable Terme = new Hashtable();
  private Hashtable Art = new Hashtable();
  private String Ausgabe = new String();
  // ENDE: Variablen deklarieren ===============================================


  // ANFANG: Konstruktor =======================================================
  public symbdiff()
  {
    // Eingabe einlesen
    Input();

    try
    {
      // Teilstrings erzeugen
      doTeilstringsErzeugen();

      // Terme erzeugen, auf Korrektheit überprüfen und Variable rausfinden
      // nach der abgeleitet werden soll
      erzeugeTerme();

      // nach der ersten gefundenen Variable ableiten
      doAbleiten();

      // Terme vereinfachen
      doVereinfachen();

      // Ausgabe
      printAusgabe();

    } catch (EprogException e)
    { // Fehlermeldung ausgeben
      EprogIO.print(Global.FEHLER); }
  }
  // ENDE: Konstruktor =========================================================


  // ANFANG: Input =============================================================
  private void Input()
  {  Eingabe = EprogIO.readWord();  }
  // ENDE: Input ===============================================================


  // ANFANG: doTeilstringsErzeugen =============================================
  private void doTeilstringsErzeugen() throws EprogException
  {
    // Temporäre Variablen deklarieren
    int Start = 0;            int Ende = 0;        int Anzahl = 0;
    boolean isTZ = false;     char Temp = ' ';

    // Schleife über den gesamten Eingabestring
    for (int i = 0; i < Eingabe.length(); i++)
    {
      // Überprüfen ob an aktueller Stelle ein Vorzeichen (+,-) ist
      if (Eingabe.charAt(i) == '+' || Eingabe.charAt(i) == '-')
      {
        // neuen Endpunkt des Teilstrings setzen
        Ende = i;

        // Teilstring in Hashtabelle abspeichern
        if (Eingabe.substring(Start,Ende).length() > 0)
          TeilString.put(new Integer(Anzahl++),Eingabe.substring(Start,Ende));

        // neuer Startpunkt ==> voriger Endpunkt
        Start = Ende;
      }
    }

    // Überprüfen ob letztes Zeichen ein Vorzeichen ist ==> Fehler
    Temp = Eingabe.charAt(Eingabe.length()-1);
    if (Temp == '+' || Temp == '-')
      throw new EprogException ("letztes Zeichen der Eingabe ist + oder -");

    // wenn letztes Zeichen kein Vorzeichen ist ==> letzten Teilstring
    // auch noch in Hashtabelle abspeichern
    if (isTZ == false)
      TeilString.put(new Integer(Anzahl),Eingabe.substring(Start));

    // falls mehr als MAXTERME Teilstrings erzeugt worden sind ==> Fehler
    if (TeilString.size()>Global.MAXTERME)
      throw new EprogException ("SYMBDIFF: zuviele Terme eingegeben");
  }
  // ENDE: doTeilstringsErzeugen ===============================================


  // ANFANG: erzeugeTerme ======================================================
  private void erzeugeTerme() throws EprogException
  {
    // Schleife über alle Teilstrings
    for (int i = 0; i < TeilString.size(); i++)
    {
      // aktuellen Teilstring in Temp abspeichern
      String Temp = (String)TeilString.get(new Integer(i));

      // --- C O S I N U S -------------------------------------------
      if (Temp.indexOf(Global.COSINUS) != -1)
      {
        // neues sincos-Objekt erzeugen
        sincos CosA = new sincos (Temp);
        CosA.sincos = true;

        // sincos-Objekt auf Korrektheit überprüfen
        CosA.checkFormatierung();

        // abspeichern in der Hashtable
        Terme.put(new Integer(i),CosA);
        Art.put(new Integer(i),Global.COSINUS);

        continue;
      }

      // --- S I N U S -----------------------------------------------
      if (Temp.indexOf(Global.SINUS) != -1)
      {
        // neues sincos-Objekt erzeugen
        sincos SinA = new sincos (Temp);
        SinA.sincos = false;

        // sincos-Objekt auf Korrektheit überprüfen
        SinA.checkFormatierung();

        // abspeichern in der Hashtable
        Terme.put(new Integer(i),SinA);
        Art.put(new Integer(i),Global.SINUS);

        continue;
      }

      // --- E U L E R -----------------------------------------------
      if (Temp.indexOf(Global.EULER) != -1)
      {
        // neues euler-Objekt erzeugen
        euler eulerA = new euler(Temp);

        // euler-Objekt auf Korrektheit überprüfen
        eulerA.checkFormatierung();

        // abspeichern in der Hashtable
        Terme.put(new Integer(i),eulerA);
        Art.put(new Integer(i),Global.EULER);

        continue;
      }

      // --- Z A H L -------------------------------------------------
      // neues zahl-Objekt erzeugen
      zahl zahlA = new zahl(Temp);

      // zahl-Objekt auf Korrektheit überprüfen
      zahlA.checkFormatierung();

      // abspeichern in der Hashtable
      Terme.put(new Integer(i),zahlA);
      Art.put(new Integer(i),Global.ZAHL);
    }
  }
  // ENDE: erzeugeTerme ========================================================


  // ANFANG: doAbleiten ========================================================
  private void doAbleiten() throws EprogException
  {
    // Schleife über alle Terme
    for (int i = 0; i < Terme.size(); i++)
    {
      // temporäre Variablen deklarieren
      String temp = (String)Art.get(new Integer(i));

      // Terme überprüfen und ableiten
      if (temp == Global.COSINUS || temp == Global.SINUS)
      {
        sincos sincosA = (sincos)Terme.get(new Integer(i));
        sincosA.doAbleitung();
      }
      else if (temp == Global.EULER)
      {
        euler eulerA = (euler)Terme.get(new Integer(i));
        eulerA.doAbleitung();
      }
      else
      {
        zahl zahlA = (zahl)Terme.get(new Integer(i));
        zahlA.doAbleitung();
      }
    }
  }
  // ENDE: doAbleiten ==========================================================

  // ANFANG: doVereinfachen ====================================================
  private void doVereinfachen() throws EprogException
  {
    Ausgabe = "";

    // Schleife über alle Terme
    for (int i = 0; i < Terme.size()-1; i++)
    {
      for (int j = (i+1); j < Terme.size(); j++)
      {
        String temp1 = (String)Art.get(new Integer(i));
        String temp2 = (String)Art.get(new Integer(j));

        // auf gleiche Art überprüfen.................
        if ((temp1.equals(temp2)) && (temp1 != null))
        {
          // ------ S I N U S / C O S I N U S ------------------------
          if (temp1.equals(Global.SINUS) || temp1.equals(Global.COSINUS))
          {
            sincos sincosA = (sincos)Terme.get(new Integer(i));
            sincos sincosB = (sincos)Terme.get(new Integer(j));
            if ((sincosA.Zahl == sincosB.Zahl) && (sincosA.x.equals(sincosB.x)))
            {
              // Koeffizienten zusammenfassen und 2.Term "löschen"
              sincosA.Koeffizient = sincosA.Koeffizient + sincosB.Koeffizient;
              sincosB.Koeffizient = 0;   sincosB.x = "";   sincosB.Zahl = 0;
            }
          }

          // ----- E U L E R --------------------------------------------
          else if (temp1.equals(Global.EULER))
          {
            euler eulerA = (euler)Terme.get(new Integer(i));
            euler eulerB = (euler)Terme.get(new Integer(j));
            if ((eulerA.Zahl == eulerB.Zahl) && (eulerA.x.equals(eulerB.x)))
            {
              // Koeffizienten zusammenfassen und 2.Term "löschen"
              eulerA.Koeffizient = eulerA.Koeffizient + eulerB.Koeffizient;
              eulerB.Koeffizient = 0;   eulerB.x = "";   eulerB.Zahl = 0;
            }
          }

          // ----- Z A H L ---------------------------------------------
          else if (temp1.equals(Global.ZAHL))
          {
            zahl zahlA = (zahl)Terme.get(new Integer(i));
            zahl zahlB = (zahl)Terme.get(new Integer(j));

            if ((zahlA.x == null) && (zahlB.x == null) &&
                (zahlA.Exponent == zahlB.Exponent))
            {
              // Koeffizienten zusammenfassen und 2.Term "löschen"
              zahlA.Koeffizient = zahlA.Koeffizient + zahlB.Koeffizient;
              zahlB.Koeffizient = 0;   zahlB.x = "";   zahlB.Exponent = 0;
            }

            else if ((zahlA.x.equals(zahlB.x)) && (zahlA.Exponent == zahlB.Exponent))
            {
              // Koeffizienten zusammenfassen und 2.Term "löschen"
              zahlA.Koeffizient = zahlA.Koeffizient + zahlB.Koeffizient;
              zahlB.Koeffizient = 0;   zahlB.x = "";   zahlB.Exponent = 0;
            }
          }
        }
      }
    }
  }
  // ENDE: doVereinfachen ======================================================


  // ANFANG: printAusgabe ======================================================
  private void printAusgabe()
  {
    // Schleife über gesamte "Terme"-Hashtable
    for (int i = 0; i < Terme.size(); i++)
    {
      String temp1 = (String)Art.get(new Integer(i));

      // ------ S I N U S / C O S I N U S ------------------------
      if (temp1.equals(Global.SINUS) || temp1.equals(Global.COSINUS))
      {
        sincos sincosA = (sincos)Terme.get(new Integer(i));
        Ausgabe += sincosA.erzeugeString();
      }
      // ----- E U L E R --------------------------------------------
      else if (temp1.equals(Global.EULER))
      {
        euler eulerA = (euler)Terme.get(new Integer(i));
        Ausgabe += eulerA.erzeugeString();
      }
      // ----- Z A H L ---------------------------------------------
      else if (temp1.equals(Global.ZAHL))
      {
        zahl zahlA = (zahl)Terme.get(new Integer(i));
        Ausgabe += zahlA.erzeugeString();
      }
    }

    // wenn der Ausgabe-Sting die Länge 0 hat ==> "0" ausgeben
    if (Ausgabe.length() == 0) EprogIO.println("0");
    else
    {
      // falls das erste Zeichen in "Ausgabe" gleich "+" ==> Zeichen aus dem
      // String entfernen
      if (Ausgabe.substring(0,1).equals("+")) Ausgabe = Ausgabe.substring(1);

      // Ausgabe des Strings
      EprogIO.println(Ausgabe);
    }
  }
  // ENDE: printAusgabe ========================================================
}