import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.awt.Graphics;
import java.lang.Math;
import java.util.*;

public class Differentiator extends Applet
{
  myPanel mp;  //用来显示题目
  Label loesung;
  Label musterloesung1;
  Label musterloesung2;
  TextField eingabe;
  Panel oben, unten, unten1,unten2;
  Button korrigierung;

  int rand_erzeugen_funk_f=-1;  //用来保存随机数，看看是哪种函数形式
  int rand_erzeugen_funk_g=-1;  //用来保存随机数，看看是哪种函数形式
  int rand_f_operant_g=-1;      //用来保存随机数，看看是哪种运算形式
  int wieviel_mal_fehler=0;
  String st_wieviel_mal_fehler;
  String st_musterloesung;

  int f_koeffizient_1, f_koeffizient_2, f_koeffizient_3;  //生成幂函数的系数
  int f_potenz_1, f_potenz_2, f_potenz_3;                 //生成幂函数的指数
  String st_f_koeffizient_1, st_f_koeffizient_2, st_f_koeffizient_3;  //把幂函数的系数转化成字符串
  String st_f_potenz_1, st_f_potenz_2, st_f_potenz_3;                 //把幂函数的指数转化成字符串
  int g_koeffizient_1, g_koeffizient_2, g_koeffizient_3;  //生成幂函数的系数
  int g_potenz_1, g_potenz_2, g_potenz_3;                 //生成幂函数的指数
  String st_g_koeffizient_1, st_g_koeffizient_2, st_g_koeffizient_3;  //把幂函数的系数转化成字符串
  String st_g_potenz_1, st_g_potenz_2, st_g_potenz_3;                 //把幂函数的指数转化成字符串

  String funk_f_kopf;
  String funk_g_kopf;
  String gesucht_kopf;
  String f_operant_g;
  String st_f;         //并无实际意义，只是在画图时用
  String st_g;         //并无实际意义，只是在画图时用
  String funk_f;       //检查输入结果是否正确时用，是真正记录字符串
  String funk_g;       //检查输入结果是否正确时用，是真正记录字符串

  String st_f_ableitung;
  String st_g_ableitung;
  String st_g_quadrat;
  String korrigierung_st;     //保存最终计算结果字符串
  String zu_vereinfachede_korrigierung;  //保存能够被化简的计算结果字符串
  String eingegeben_st;       //保存用户输入的字符串

  boolean kann_vereinfachen=false;  //看看是否能化简
  boolean funk_f_sin=false;
  boolean funk_f_cos=false;
  boolean funk_f_pot=false;
  boolean funk_f_exp=false;
  boolean funk_g_cos=false;
  boolean funk_g_sin=false;
  boolean funk_g_pot=false;
  boolean funk_g_exp=false;
  boolean f_add_g=false;
  boolean f_minus_g=false;
  boolean f_multi_g=false;
  boolean f_div_g=false;
  boolean f_g=false;
  Random ran;

  public void init()
  {
    funk_f_kopf="Gegeben: f(x)=";
    funk_g_kopf="g(x)=";
    gesucht_kopf="Gesucht: ";
    ran = new Random();

    setBackground(Color.white);
    setLayout(new BorderLayout());

    oben = new Panel();
    oben.setLayout(new GridLayout(2,1));
    add(oben,BorderLayout.NORTH);
    Button start=new Button("neue Aufgabe");
    start.setBackground(Color.lightGray);
    oben.add(start);
    loesung = new Label("Die Antwort lautet ............");
    oben.add(loesung);
    korrigierung = new Button ("Kontrolle");
    korrigierung.setBackground(Color.lightGray);
    mp = new myPanel(this);
    add(mp, BorderLayout.CENTER);

    start.addActionListener(new ActionListener()  //出题的按钮开始
    {
      public void actionPerformed(ActionEvent e)
      {
        eingabe.setEditable(true);      //设置文本框为可见
        korrigierung.setEnabled(true);  //设置按钮为可见
        wieviel_mal_fehler=0;
        rand_erzeugen_funk_f=(int)(Math.random()*8); //根据随机数来产生函数形式
        rand_erzeugen_funk_g=(int)(Math.random()*8); //根据随机数来产生函数形式
        rand_f_operant_g=(int)(Math.random()*10);    //根据随机数确定f和g的关系

        f_koeffizient_1=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数，除以8的最大余数是7
        f_koeffizient_2=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数，除以8的最大余数是7
        f_koeffizient_3=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数，除以8的最大余数是7
        st_f_koeffizient_1=String.valueOf(f_koeffizient_1);  //将系数转换成字符串
        st_f_koeffizient_2=String.valueOf(f_koeffizient_2);  //将系数转换成字符串
        st_f_koeffizient_3=String.valueOf(f_koeffizient_3);  //将系数转换成字符串

        f_potenz_1=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第一项的幂
        while(f_potenz_1<5)                          //看看第一项的幂是不是小于5，如果小于5
             f_potenz_1=Math.abs(ran.nextInt()%7)+3; //要重新生成，为了降幂排列
        f_potenz_2=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第二项的幂
        while((f_potenz_2>=f_potenz_1)||(f_potenz_2<4)) //看看第二项的幂是不是比第一项的小且大于3
             f_potenz_2=Math.abs(ran.nextInt()%7)+3;   //如果不满足就重新生成
        f_potenz_3=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第三项的幂
        while(f_potenz_3>=f_potenz_2)
             f_potenz_3=Math.abs(ran.nextInt()%7)+3;
        st_f_potenz_1=String.valueOf(f_potenz_1);            //将幂转换成字符串
        st_f_potenz_2=String.valueOf(f_potenz_2);            //将幂转换成字符串
        st_f_potenz_3=String.valueOf(f_potenz_3);            //将幂转换成字符串

        g_koeffizient_1=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数
        g_koeffizient_2=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数
        g_koeffizient_3=Math.abs(ran.nextInt()%8)+2;               //根据随机数生成系数
        st_g_koeffizient_1=String.valueOf(g_koeffizient_1);  //将系数转换成字符串
        st_g_koeffizient_2=String.valueOf(g_koeffizient_2);  //将系数转换成字符串
        st_g_koeffizient_3=String.valueOf(g_koeffizient_3);  //将系数转换成字符串

        g_potenz_1=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第一项的幂
        while(g_potenz_1<5)                          //看看第一项的幂是不是小于5，如果小于5
             g_potenz_1=Math.abs(ran.nextInt()%7)+3; //要重新生成，为了降幂排列
        g_potenz_2=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第二项的幂
        while((g_potenz_2>=g_potenz_1)||(g_potenz_2<4))
             g_potenz_2=Math.abs(ran.nextInt()%7)+3;
        g_potenz_3=Math.abs(ran.nextInt()%7)+3;      //根据随机数生成第三项的幂
        while(g_potenz_3>=g_potenz_2)
             g_potenz_3=Math.abs(ran.nextInt()%7)+3;
        st_g_potenz_1=String.valueOf(g_potenz_1);            //将幂转换成字符串
        st_g_potenz_2=String.valueOf(g_potenz_2);            //将幂转换成字符串
        st_g_potenz_3=String.valueOf(g_potenz_3);            //将幂转换成字符串

        if((rand_f_operant_g>=0)&&(rand_f_operant_g<2))
        {
          f_add_g=true;
          f_minus_g=false;
          f_multi_g=false;
          f_div_g=false;
          f_g=false;
        }
        if((rand_f_operant_g>=2)&&(rand_f_operant_g<4))
        {
          f_add_g=false;
          f_minus_g=true;
          f_multi_g=false;
          f_div_g=false;
          f_g=false;
        }
        if((rand_f_operant_g>=4)&&(rand_f_operant_g<6))
        {
          f_add_g=false;
          f_minus_g=false;
          f_multi_g=true;
          f_div_g=false;
          f_g=false;
        }
        if((rand_f_operant_g>=6)&&(rand_f_operant_g<8))
        {
          f_add_g=false;
          f_minus_g=false;
          f_multi_g=false;
          f_div_g=true;
          f_g=false;
        }
        if((rand_f_operant_g>=8)&&(rand_f_operant_g<10))
        {
          f_add_g=false;
          f_minus_g=false;
          f_multi_g=false;
          f_div_g=false;
          f_g=true;
        }
        if((rand_erzeugen_funk_f>=0)&&(rand_erzeugen_funk_f<2))
        {
          funk_f_sin=true;
          funk_f_cos=false;
          funk_f_pot=false;
          funk_f_exp=false;
        }
        if((rand_erzeugen_funk_f>=2)&&(rand_erzeugen_funk_f<4))
        {
          funk_f_sin=false;
          funk_f_cos=true;
          funk_f_pot=false;
          funk_f_exp=false;
        }
        if((rand_erzeugen_funk_f>=4)&&(rand_erzeugen_funk_f<6))
        {
          funk_f_sin=false;
          funk_f_cos=false;
          funk_f_pot=true;
          funk_f_exp=false;
        }
        if((rand_erzeugen_funk_f>=6)&&(rand_erzeugen_funk_f<=8))
        {
          funk_f_sin=false;
          funk_f_cos=false;
          funk_f_pot=false;
          funk_f_exp=true;
        }
        if((rand_erzeugen_funk_g>=0)&&(rand_erzeugen_funk_g<2))
        {
          funk_g_sin=true;
          funk_g_cos=false;
          funk_g_pot=false;
          funk_g_exp=false;
        }
        if((rand_erzeugen_funk_g>=2)&&(rand_erzeugen_funk_g<4))
        {
          funk_g_sin=false;
          funk_g_cos=true;
          funk_g_pot=false;
          funk_g_exp=false;
        }
        if((rand_erzeugen_funk_g>=4)&&(rand_erzeugen_funk_g<6))
        {
          funk_g_sin=false;
          funk_g_cos=false;
          funk_g_pot=true;
          funk_g_exp=false;
        }
        if((rand_erzeugen_funk_g>=6)&&(rand_erzeugen_funk_g<=8))
        {
          funk_g_sin=false;
          funk_g_cos=false;
          funk_g_pot=false;
          funk_g_exp=true;
        }

        if(funk_f_sin) st_f="sin(x)";
        if(funk_f_cos) st_f="cos(x)";
        if(funk_f_pot) st_f="x";
        if(funk_f_exp) st_f="a";
        if(funk_g_sin) st_g="sin(x)";
        if(funk_g_cos) st_g="cos(x)";
        if(funk_g_pot) st_g="x";
        if(funk_g_exp) st_g="a";
        if(f_add_g) f_operant_g="(f(x)+g(x)) '";
        if(f_minus_g) f_operant_g="(f(x)-g(x)) '";
        if(f_multi_g) f_operant_g="(f(x)*g(x)) '";
        if(f_div_g) f_operant_g="(f(x)/g(x)) '";
        if(f_g) f_operant_g="f(g(x)) '";

        ableitung_rechnen();

        mp.malefunk();

        loesung.setText("Die Antwort lautet ............");
        eingabe.setText("");
        musterloesung1.setText("Musterloeung: (erscheint bei 5 falschen Antworten)");
        musterloesung2.setText("");
      }
    });  //出题的按钮结束

    unten = new Panel();
    unten1 = new Panel();
    unten2 = new Panel();
    unten.setLayout(new BorderLayout());
    unten.add(unten1,BorderLayout.NORTH);
    unten.add(unten2,BorderLayout.CENTER);
    unten1.setLayout(new BorderLayout());
    Label bitte= new Label(" Loesung=");
    unten1.add(bitte,BorderLayout.WEST);
    eingabe = new TextField(100);
    unten1.add(eingabe,BorderLayout.CENTER);
    unten2.setLayout(new GridLayout(3,1));
    unten2.add(korrigierung);
    musterloesung1 = new Label("Musterloeung: (erscheint bei 5 falschen Antworten)");
    musterloesung2 = new Label("");
    unten2.add(musterloesung1);
    unten2.add(musterloesung2);

    korrigierung.addActionListener(new ActionListener()   //检查结果的按钮开始
    {
      public void actionPerformed(ActionEvent e)
      {
        eingegeben_st=eingabe.getText();

////////////////////////去掉字符串中的空格开始/////////////////////////////////////
        StringTokenizer leer_entfernen=new StringTokenizer(eingegeben_st," ");
        String[] hilf_leer_entfernen=new String[leer_entfernen.countTokens()];
        for(int i=0;i<hilf_leer_entfernen.length;i++)
           hilf_leer_entfernen[i]=leer_entfernen.nextToken();
        eingegeben_st="  ";
        for(int i=0;i<hilf_leer_entfernen.length;i++)
           eingegeben_st +=hilf_leer_entfernen[i];
        eingegeben_st=eingegeben_st.trim();     //将字符串前面的空格去掉

////////////////////////去掉字符串中的空格结束/////////////////////////////////////

////////////////////////去掉字符串中的星号开始/////////////////////////////////////
        StringTokenizer stern_entfernen=new StringTokenizer(eingegeben_st,"*");
        String[] hilf_stern_entfernen=new String[stern_entfernen.countTokens()];
        for(int i=0;i<hilf_stern_entfernen.length;i++)
           hilf_stern_entfernen[i]=stern_entfernen.nextToken();
        eingegeben_st="  ";
        for(int i=0;i<hilf_stern_entfernen.length;i++)
           eingegeben_st +=hilf_stern_entfernen[i];
        eingegeben_st=eingegeben_st.trim();     //将字符串前面的空格去掉

////////////////////////去掉字符串中的星号结束/////////////////////////////////////

        if(test())
        {
          if(kann_vereinfachen)
            loesung.setText("Die Antwort ist richtig, aber die Loesung kann noch vereinfacht werden!");
          else {
                 loesung.setText("Die Antwort ist richtig !!!");
                 eingabe.setEditable(false);      //设置文本框为不可见
                 korrigierung.setEnabled(false);  //设置按钮为不可见
               }
        }
        else{
              wieviel_mal_fehler++;
              if(wieviel_mal_fehler>5) wieviel_mal_fehler=5;
              st_wieviel_mal_fehler="Die Antwort ist "+String.valueOf(wieviel_mal_fehler)+
                                    " mal falsch !!!";
              loesung.setText(st_wieviel_mal_fehler);
            }
        if(wieviel_mal_fehler==5)
        {
          eingabe.setEditable(false);      //设置文本框为不可见
          korrigierung.setEnabled(false);  //设置按钮为不可见
          st_musterloesung="Die Musterloesung lautet : "+korrigierung_st;
          if(st_musterloesung.length()<=80)
          {
            musterloesung1.setText(st_musterloesung);
            musterloesung2.setText("");
          }
          else{
                musterloesung1.setText(st_musterloesung.substring(0,80));
                musterloesung2.setText(st_musterloesung.substring(80,st_musterloesung.length()));
              }
        }
      }
    });   //检查结果的按钮结束

    add(unten, BorderLayout.SOUTH);
    setVisible(true);
  }

////////////////////////导数计算函数开始//////////////////////////////////////////////////////
  public void ableitung_rechnen()
  {
    if(funk_f_sin) funk_f="sin(x)";
    if(funk_f_cos) funk_f="cos(x)";
    if(funk_f_exp) funk_f="a^x";
    if(funk_f_pot) funk_f=st_f_koeffizient_1+"x^"+st_f_potenz_1+"+"+
                          st_f_koeffizient_2+"x^"+st_f_potenz_2+"+"+
                          st_f_koeffizient_3+"x^"+st_f_potenz_3;
    if(funk_g_sin) funk_g="sin(x)";
    if(funk_g_cos) funk_g="cos(x)";
    if(funk_g_exp) funk_g="a^x";
    if(funk_g_pot) funk_g=st_g_koeffizient_1+"x^"+st_g_potenz_1+"+"+
                          st_g_koeffizient_2+"x^"+st_g_potenz_2+"+"+
                          st_g_koeffizient_3+"x^"+st_g_potenz_3;

    if((funk_f_sin)&&(!f_g)) st_f_ableitung="cos(x)";
    if(funk_g_sin)
    {
      st_g_quadrat="(sin(x))^2";
      st_g_ableitung="cos(x)";
    }
    if((funk_f_cos)&&(!f_g)) st_f_ableitung="-sin(x)";
    if(funk_g_cos)
    {
      st_g_quadrat="(cos(x))^2";
      st_g_ableitung="sin(x)";
    }
    if((funk_f_exp)&&(!f_g)) st_f_ableitung="a^xln(a)";
    if(funk_g_exp)
    {
      st_g_quadrat="a^(2x)";
      st_g_ableitung="a^xln(a)";
    }
    if((funk_f_pot)&&(!f_g))
    {
      st_f_ableitung=String.valueOf(f_koeffizient_1*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1)+"+"+
                     String.valueOf(f_koeffizient_2*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1)+"+"+
                     String.valueOf(f_koeffizient_3*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
    }
    if(funk_g_pot)
    {
      st_g_quadrat="("+String.valueOf(g_koeffizient_1)+"x^"+String.valueOf(g_potenz_1)+"+"+
                       String.valueOf(g_koeffizient_2)+"x^"+String.valueOf(g_potenz_2)+"+"+
                       String.valueOf(g_koeffizient_3)+"x^"+String.valueOf(g_potenz_3)+
                   ")^2";
      st_g_ableitung=String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1)+"+"+
                     String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1)+"+"+
                     String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);
    }

    if(funk_f_sin&&f_g) st_f_ableitung="cos("+funk_g+")";
    if(funk_f_cos&&f_g) st_f_ableitung="-sin("+funk_g+")";
    if(funk_f_exp&&f_g) st_f_ableitung="a^("+funk_g+")"+"ln(a)";
    if(funk_f_pot&&f_g) st_f_ableitung=
                           String.valueOf(f_koeffizient_1*f_potenz_1)+"("+funk_g+")^"+String.valueOf(f_potenz_1-1)+"+"+
                           String.valueOf(f_koeffizient_2*f_potenz_2)+"("+funk_g+")^"+String.valueOf(f_potenz_2-1)+"+"+
                           String.valueOf(f_koeffizient_3*f_potenz_3)+"("+funk_g+")^"+String.valueOf(f_potenz_3-1);

    if(f_add_g)
    {
      if(funk_g_cos)
        korrigierung_st=st_f_ableitung+"-"+st_g_ableitung;
      else korrigierung_st=st_f_ableitung+"+"+st_g_ableitung;

      if(funk_f_sin&&funk_g_sin)
      {
        korrigierung_st="2cos(x)";
        zu_vereinfachede_korrigierung="cos(x)+cos(x)";
      }
      if(funk_f_cos&&funk_g_cos)
      {
        korrigierung_st="-2sin(x)";
        zu_vereinfachede_korrigierung="-sin(x)-sin(x)";
      }
      if(funk_f_exp&&funk_g_exp)
      {
        korrigierung_st="2a^xln(a)";
        zu_vereinfachede_korrigierung="a^xln(a)+a^xln(a)";
      }
      if(funk_f_pot&&funk_g_pot)
      {
        zu_vereinfachede_korrigierung=String.valueOf(f_koeffizient_1*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1)+"+"+
                                      String.valueOf(f_koeffizient_2*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1)+"+"+
                                      String.valueOf(f_koeffizient_3*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1)+"+"+
                                      String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1)+"+"+
                                      String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1)+"+"+
                                      String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);

        if(f_potenz_1==g_potenz_1)
          korrigierung_st=String.valueOf((f_koeffizient_1+g_koeffizient_1)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        else if(f_potenz_1==g_potenz_2)
          korrigierung_st=String.valueOf((f_koeffizient_1+g_koeffizient_2)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        else if(f_potenz_1==g_potenz_3)
          korrigierung_st=String.valueOf((f_koeffizient_1+g_koeffizient_3)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        else
          korrigierung_st=String.valueOf(f_koeffizient_1*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);

        if(f_potenz_2==g_potenz_1)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2+g_koeffizient_1)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        else if(f_potenz_2==g_potenz_2)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2+g_koeffizient_2)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        else if(f_potenz_2==g_potenz_3)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2+g_koeffizient_3)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        else
          korrigierung_st +="+"+String.valueOf(f_koeffizient_2*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);

        if(f_potenz_3==g_potenz_1)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3+g_koeffizient_1)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        else if(f_potenz_3==g_potenz_2)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3+g_koeffizient_2)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        else if(f_potenz_3==g_potenz_3)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3+g_koeffizient_3)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        else
          korrigierung_st +="+"+String.valueOf(f_koeffizient_3*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);

        if((g_potenz_1!=f_potenz_1)&&(g_potenz_1!=f_potenz_2)&&(g_potenz_1!=f_potenz_3))
          korrigierung_st +="+"+String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1);
        if((g_potenz_2!=f_potenz_1)&&(g_potenz_2!=f_potenz_2)&&(g_potenz_2!=f_potenz_3))
          korrigierung_st +="+"+String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1);
        if((g_potenz_3!=f_potenz_1)&&(g_potenz_3!=f_potenz_2)&&(g_potenz_3!=f_potenz_3))
          korrigierung_st +="+"+String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);
      }
    }
    if(f_minus_g)
    {
      if(funk_g_cos)
        korrigierung_st=st_f_ableitung+"+"+st_g_ableitung;
      else if(funk_g_pot)
        korrigierung_st=st_f_ableitung+"-"+
                        String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1)+"-"+
                        String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1)+"-"+
                        String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);
      else korrigierung_st=st_f_ableitung+"-"+st_g_ableitung;

      if(funk_f_sin&&funk_g_sin)
      {
        korrigierung_st="0";
        zu_vereinfachede_korrigierung="cos(x)-cos(x)";
      }
      if(funk_f_cos&&funk_g_cos)
      {
        korrigierung_st="0";
        zu_vereinfachede_korrigierung="-sin(x)+sin(x)";
      }
      if(funk_f_exp&&funk_g_exp)
      {
        korrigierung_st="0";
        zu_vereinfachede_korrigierung="a^xln(a)-a^xln(a)";
      }
      if(funk_f_pot&&funk_g_pot)
      {
        zu_vereinfachede_korrigierung=String.valueOf(f_koeffizient_1*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1)+"+"+
                                      String.valueOf(f_koeffizient_2*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1)+"+"+
                                      String.valueOf(f_koeffizient_3*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1)+"-"+
                                      String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1)+"-"+
                                      String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1)+"-"+
                                      String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);

        if(f_potenz_1==g_potenz_1)
        {
          if((f_koeffizient_1-g_koeffizient_1)==0) korrigierung_st="";
          else
          korrigierung_st=String.valueOf((f_koeffizient_1-g_koeffizient_1)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        }
        else if(f_potenz_1==g_potenz_2)
        {
          if((f_koeffizient_1-g_koeffizient_2)==0) korrigierung_st="";
          else
          korrigierung_st=String.valueOf((f_koeffizient_1-g_koeffizient_2)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        }
        else if(f_potenz_1==g_potenz_3)
        {
          if((f_koeffizient_1-g_koeffizient_3)==0) korrigierung_st="";
          else
          korrigierung_st=String.valueOf((f_koeffizient_1-g_koeffizient_3)*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);
        }
        else
          korrigierung_st=String.valueOf(f_koeffizient_1*f_potenz_1)+"x^"+String.valueOf(f_potenz_1-1);

        if(f_potenz_2==g_potenz_1)
        {
          if((f_koeffizient_2-g_koeffizient_1)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2-g_koeffizient_1)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
          else if((f_koeffizient_2-g_koeffizient_1)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_2-g_koeffizient_1)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        }
        else if(f_potenz_2==g_potenz_2)
        {
          if((f_koeffizient_2-g_koeffizient_2)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2-g_koeffizient_2)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
          else if((f_koeffizient_2-g_koeffizient_2)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_2-g_koeffizient_2)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        }
        else if(f_potenz_2==g_potenz_3)
        {
          if((f_koeffizient_2-g_koeffizient_3)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_2-g_koeffizient_3)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
          else if((f_koeffizient_2-g_koeffizient_3)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_2-g_koeffizient_3)*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);
        }
        else
          korrigierung_st +="+"+String.valueOf(f_koeffizient_2*f_potenz_2)+"x^"+String.valueOf(f_potenz_2-1);

        if(f_potenz_3==g_potenz_1)
        {
          if((f_koeffizient_3-g_koeffizient_1)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3-g_koeffizient_1)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
          else if((f_koeffizient_3-g_koeffizient_1)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_3-g_koeffizient_1)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        }
        else if(f_potenz_3==g_potenz_2)
        {
          if((f_koeffizient_3-g_koeffizient_2)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3-g_koeffizient_2)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
          else if((f_koeffizient_3-g_koeffizient_2)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_3-g_koeffizient_2)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        }
        else if(f_potenz_3==g_potenz_3)
        {
          if((f_koeffizient_3-g_koeffizient_3)>0)
          korrigierung_st +="+"+String.valueOf((f_koeffizient_3-g_koeffizient_3)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
          else if((f_koeffizient_3-g_koeffizient_3)==0){}
          else
          korrigierung_st +=String.valueOf((f_koeffizient_3-g_koeffizient_3)*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);
        }
        else
          korrigierung_st +="+"+String.valueOf(f_koeffizient_3*f_potenz_3)+"x^"+String.valueOf(f_potenz_3-1);

        if((g_potenz_1!=f_potenz_1)&&(g_potenz_1!=f_potenz_2)&&(g_potenz_1!=f_potenz_3))
          korrigierung_st +="-"+String.valueOf(g_koeffizient_1*g_potenz_1)+"x^"+String.valueOf(g_potenz_1-1);
        if((g_potenz_2!=f_potenz_1)&&(g_potenz_2!=f_potenz_2)&&(g_potenz_2!=f_potenz_3))
          korrigierung_st +="-"+String.valueOf(g_koeffizient_2*g_potenz_2)+"x^"+String.valueOf(g_potenz_2-1);
        if((g_potenz_3!=f_potenz_1)&&(g_potenz_3!=f_potenz_2)&&(g_potenz_3!=f_potenz_3))
          korrigierung_st +="-"+String.valueOf(g_koeffizient_3*g_potenz_3)+"x^"+String.valueOf(g_potenz_3-1);
      }
    }
    if(f_multi_g)
    {
      if(funk_f_pot)
      {
        if(funk_g_pot)
        {
          korrigierung_st="("+st_f_ableitung+")"+"("+funk_g+")"+"+"+"("+funk_f+")"+"("+st_g_ableitung+")";
        }
        else if(funk_g_cos)
             korrigierung_st="("+st_f_ableitung+")"+funk_g+"-"+"("+funk_f+")"+st_g_ableitung;
        else korrigierung_st="("+st_f_ableitung+")"+funk_g+"+"+"("+funk_f+")"+st_g_ableitung;
      }
      else if(funk_g_pot)
             korrigierung_st=st_f_ableitung+"("+funk_g+")"+"+"+funk_f+"("+st_g_ableitung+")";
      else if(funk_g_cos)
        korrigierung_st=st_f_ableitung+funk_g+"-"+funk_f+st_g_ableitung;
      else korrigierung_st=st_f_ableitung+funk_g+"+"+funk_f+st_g_ableitung;

      if(funk_f_sin&&funk_g_sin)
      {
        zu_vereinfachede_korrigierung="cos(x)sin(x)+sin(x)cos(x)";
        korrigierung_st="sin(2x)";
      }
      if(funk_f_cos&&funk_g_cos)
      {
        zu_vereinfachede_korrigierung="-sin(x)cos(x)-cos(x)sin(x)";
        korrigierung_st="-sin(2x)";
      }
      if(funk_f_exp&&funk_g_exp)
      {
        zu_vereinfachede_korrigierung="a^xln(a)a^x+a^xa^xln(a)";
        korrigierung_st="2a^(2x)ln(a)";
      }
      if(funk_f_sin&&funk_g_cos)
      {
        zu_vereinfachede_korrigierung="cos(x)cos(x)-sin(x)sin(x)";
        korrigierung_st="cos(2x)";
      }
      if(funk_f_cos&&funk_g_sin)
      {
        zu_vereinfachede_korrigierung="-sin(x)sin(x)+cos(x)cos(x)";
        korrigierung_st="cos(2x)";
      }
    }
    if(f_div_g)
    {
      if(funk_f_pot)
      {
        if(funk_g_pot)
           korrigierung_st="("+"("+st_f_ableitung+")"+"("+funk_g+")"+"-"+"("+funk_f+")"+"("+st_g_ableitung+")"+")"
                           +"/"+st_g_quadrat;
        else if(funk_g_cos)
           korrigierung_st="("+"("+st_f_ableitung+")"+funk_g+"+"+"("+funk_f+")"+st_g_ableitung+")"
                           +"/"+st_g_quadrat;
        else if(funk_g_exp)
           {
             korrigierung_st="("+st_f_ableitung+"-"+"("+funk_f+")"+"ln(a)"+")"
                             +"/"+"a^x";
             zu_vereinfachede_korrigierung="("+"("+st_f_ableitung+")"+funk_g+"-"+"("+funk_f+")"+st_g_ableitung+")"
                                           +"/"+st_g_quadrat;
           }
        else korrigierung_st="("+"("+st_f_ableitung+")"+funk_g+"-"+"("+funk_f+")"+st_g_ableitung+")"
                             +"/"+st_g_quadrat;
      }
      else if(funk_g_pot)
        korrigierung_st="("+st_f_ableitung+"("+funk_g+")"+"-"+funk_f+"("+st_g_ableitung+")"+")"
                        +"/"+st_g_quadrat;
      else if(funk_g_cos)
        korrigierung_st="("+st_f_ableitung+funk_g+"+"+funk_f+st_g_ableitung+")"
                        +"/"+st_g_quadrat;
      else if(funk_g_exp)
        {
          zu_vereinfachede_korrigierung="("+st_f_ableitung+funk_g+"-"+funk_f+st_g_ableitung+")"
                                        +"/"+st_g_quadrat;
          korrigierung_st="("+st_f_ableitung+"-"+funk_f+"ln(a)"+")"+"/"+"a^x";
        }
      else korrigierung_st="("+st_f_ableitung+funk_g+"-"+funk_f+st_g_ableitung+")"+"/"+st_g_quadrat;

      if(funk_f_sin&&funk_g_sin) 
      {
        zu_vereinfachede_korrigierung="(cos(x)sin(x)-sin(x)cos(x))/(sin(x))^2";
        korrigierung_st="0";
      }
      if(funk_f_cos&&funk_g_cos)
      {
        zu_vereinfachede_korrigierung="(-sin(x)cos(x)+cos(x)sin(x))/(cos(x))^2";
        korrigierung_st="0";
      }
      if(funk_f_exp&&funk_g_exp) 
      {
        zu_vereinfachede_korrigierung="(a^xln(a)a^x-a^xa^xln(a))/a^(2x)";
        korrigierung_st="0";
      }
      if(funk_f_sin&&funk_g_cos)
      {
        zu_vereinfachede_korrigierung="(cos(x)cos(x)+sin(x)sin(x))/(cos(x))^2";
        korrigierung_st="1/(cos(x))^2";
      }
      if(funk_f_cos&&funk_g_sin)
      {
        zu_vereinfachede_korrigierung="(-sin(x)sin(x)-cos(x)cos(x))/(sin(x))^2";
        korrigierung_st="-1/(sin(x))^2";
      }
    }
    if(f_g)
    {
      if(funk_f_pot)
      {
        if(funk_g_exp)
        {
          korrigierung_st="("+String.valueOf(f_koeffizient_1*f_potenz_1)+"a^("+
                        String.valueOf(f_potenz_1-1)+"x)+"+String.valueOf(f_koeffizient_2*f_potenz_2)+"a^("+
                        String.valueOf(f_potenz_2-1)+"x)+"+String.valueOf(f_koeffizient_3*f_potenz_3)+"a^("+
                        String.valueOf(f_potenz_3-1)+"x))a^xln(a)";
          zu_vereinfachede_korrigierung="("+st_f_ableitung+")"+st_g_ableitung;
        }
        else if(funk_g_cos)
          korrigierung_st="-("+st_f_ableitung+")"+st_g_ableitung;
        else if(funk_g_sin)
          korrigierung_st="("+st_f_ableitung+")"+st_g_ableitung;
        else korrigierung_st="("+st_f_ableitung+")"+"("+st_g_ableitung+")";
      }
      else if(funk_g_pot)
        korrigierung_st=st_f_ableitung+"("+st_g_ableitung+")";
      else if(funk_g_cos)
        korrigierung_st="-"+st_f_ableitung+st_g_ableitung;
      else korrigierung_st=st_f_ableitung+st_g_ableitung;

      if(funk_f_exp&&funk_g_exp)
      {
        zu_vereinfachede_korrigierung="a^(a^x)ln(a)a^xln(a)";
        korrigierung_st="a^(a^x)a^xln(2a)";
      }
      if(funk_f_cos&&funk_g_cos) 
      {
        zu_vereinfachede_korrigierung="-sin(cos(x))(-sin(x))";
        korrigierung_st="sin(cos(x))sin(x)";
      }
    }
  }
////////////////////////导数计算函数结束//////////////////////////////////////////////////////

  public boolean test()
  {
    if(eingegeben_st.equals(korrigierung_st))
    {
      kann_vereinfachen=false;
      return true;
    }
    else if(eingegeben_st.equals(zu_vereinfachede_korrigierung))
         {
           kann_vereinfachen=true;
           return true;
         }
    else{ 
          return false;
        }
  }

  public void start()
  {
    mp.init();
  }

/////////////////////////////用来显示题目的内部类定义开始//////////////////////////////////////////////
  public class myPanel extends Panel
  {
    Differentiator diff;
    Image img;
    Graphics imggc;
    FontMetrics fm;
    int width,height;
    StringBuffer korrigierungBf;

    public myPanel(Differentiator d)
    {
      diff=d;
    }

    public void init()
    {
      if (img==null)
      {
        Dimension d=getSize();
        width=d.width; height=d.height;
        img=createImage(width,height);
        imggc=img.getGraphics();
        Font f = new Font ("Serif", Font.BOLD, 20);
        imggc.setFont (f);
        fm = getFontMetrics(f);
        validate();
      }
    }

    public void paint(Graphics gc)
    {
      if (img!=null) gc.drawImage(img,0,0,diff);
            
    }
        
    public void update(Graphics gc)
    {
      if (img!=null) gc.drawImage(img,0,0,diff);
    }

    public void malefunk()
    {
      int breite_f, breite_g;
      String gesamt_f;
      String gesamt_g;
      String gesamt_gesucht;

      if(funk_f_pot)
        gesamt_f=funk_f_kopf+st_f_koeffizient_1+st_f;
      else gesamt_f=funk_f_kopf+st_f;

      if(funk_g_pot)
        gesamt_g=funk_g_kopf+st_g_koeffizient_1+st_g;
      else gesamt_g=funk_g_kopf+st_g;

      gesamt_gesucht=gesucht_kopf+f_operant_g;

      breite_f=fm.stringWidth(gesamt_f);
      breite_g=fm.stringWidth(gesamt_g);
      imggc.setColor(Color.white);
      imggc.fillRect(0,0,width, height);
      imggc.setColor(Color.black);

      if(funk_f_pot)
      {
        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        imggc.drawString( gesamt_f, 5, 40);                     //写幂函数第一项的底
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_f_potenz_1, 5+2+breite_f, 40 - 7); //写幂函数第一项的幂

        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        gesamt_f="+"+st_f_koeffizient_2+st_f;
        imggc.drawString( gesamt_f, 5+2+breite_f+10, 40);        //写幂函数第二项的底
        breite_f +=fm.stringWidth(gesamt_f);                      //字符串的宽度要累加
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_f_potenz_2, 5+2+breite_f+10, 40 - 7); //写幂函数第二项的幂

        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        gesamt_f="+"+st_f_koeffizient_3+st_f;
        imggc.drawString( gesamt_f, 5+2+breite_f+2+14, 40);        //写幂函数第三项的底
        breite_f +=fm.stringWidth(gesamt_f);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_f_potenz_3, 5+2+breite_f+14, 40 - 7);  //写幂函数第三项的幂
      }
      else if(funk_f_exp)
      {
        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        imggc.drawString( gesamt_f, 5, 40);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( "x", 5+2+breite_f, 40 - 7);
      }
      else{
            imggc.setFont (new Font( "Serif", Font.BOLD, 20));
            imggc.drawString( gesamt_f, 5, 40);
          }
      if(funk_g_pot)
      {
        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        imggc.drawString( gesamt_g, 300, 40);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_g_potenz_1, 300+2+breite_g, 40 - 7);

        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        gesamt_g="+"+st_g_koeffizient_2+st_g;
        imggc.drawString( gesamt_g, 300+2+breite_g+10, 40);
        breite_g +=fm.stringWidth(gesamt_g);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_g_potenz_2, 300+2+breite_g+10, 40 - 7);

        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        gesamt_g="+"+st_g_koeffizient_3+st_g;
        imggc.drawString( gesamt_g, 300+2+breite_g+2+14, 40);
        breite_g +=fm.stringWidth(gesamt_g);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( st_g_potenz_3, 300+2+breite_g+14, 40 - 7);
      }
      else if(funk_g_exp)
      {
        imggc.setFont (new Font( "Serif", Font.BOLD, 20));
        imggc.drawString( gesamt_g, 300, 40);
        imggc.setFont (new Font( "Serif", Font.BOLD, 16));
        imggc.drawString( "x", 300+2+breite_g, 40 - 7);
      }
      else{
            imggc.setFont (new Font( "Serif", Font.BOLD, 20));
            imggc.drawString( gesamt_g, 300, 40);
          }
      imggc.setFont (new Font( "Serif", Font.BOLD, 20));
      imggc.drawString( gesamt_gesucht, 5, 100);

      repaint();
    }

  }//end of class myPanel
/////////////////////////////用来显示题目的内部类定义结束//////////////////////////////////////////////

  public static void main( String[] args)
  {
    new Differentiator();
  }

}//end of class Differentiator