abstract class Wyrazenie {
    public Wyrazenie dodaj(Wyrazenie w) { return w.dodajOdwrotnie(this); }
    public Wyrazenie odejmij(Wyrazenie w) { return w.odejmijOdwrotnie(this); }
    public Wyrazenie pomnóş(Wyrazenie w) { return w.pomnóşOdwrotnie(this); }
    public Wyrazenie podziel(Wyrazenie w) { return w.podzielOdwrotnie(this); }

    Wyrazenie dodajOdwrotnie(Wyrazenie w) { return new Plus(w, this); }
    Wyrazenie odejmijOdwrotnie(Wyrazenie w) { return new Minus(w, this); }
    Wyrazenie pomnóşOdwrotnie(Wyrazenie w) { return new Razy(w, this); }
    Wyrazenie podzielOdwrotnie(Wyrazenie w) { return new Dzielenie(w, this); }
    /* to niestety jest potrzebne aby działo upraszczanie stałych */
    Wyrazenie dodajOdwrotnie(Stała w) { return dodajOdwrotnie((Wyrazenie) w); }
    Wyrazenie odejmijOdwrotnie(Stała w) { return odejmijOdwrotnie((Wyrazenie) w); }
    Wyrazenie pomnóżOdwrotnie(Stała w) { return pomnóżOdwrotnie((Wyrazenie) w); }
    Wyrazenie podzielOdwrotnie(Stała w) { return podzielOdwrotnie((Wyrazenie) w); }


    public abstract double wartość(double x);
    public abstract Wyrazenie pochodna();

    public double całka(double l, double r, int n) {
        double delta=(r-l)/n;
        double res=0;
        for(int i=0;i<n;i++) {
            double x0=l+delta*i;
            double x1=l+delta*(i+1);
            res += (wartość(x0)+wartość(x1))*delta/2;
        }
        return res;
    }
    int priorytet() { return 100000; }
}

class Stała extends Wyrazenie {
    protected final double wart;

    protected Stała(double wart) {
        this.wart = wart;
    }

    public static Stała twórz(double x) {
        if (x==0.0) return Zero.twĂłrz();
        else if (x==1.0) return Jeden.twĂłrz();
        else return new Stała(x);
    }

    public String toString() { return ""+this.wart; }

    public double wartość(double x) { return this.wart; }

    public Wyrazenie dodaj(Stała w) { return twórz(this.wart+w.wart); }
    public Wyrazenie dodaj(Wyrazenie w) { return w.dodajOdwrotnie(this); }
    Wyrazenie dodajOdwrotnie(Stała w) { return twórz(w.wart+this.wart); }
    public Wyrazenie odejmij(Stała w) { return twórz(this.wart-w.wart); }
    public Wyrazenie odejmij(Wyrazenie w) { return w.odejmijOdwrotnie(this); }
    Wyrazenie odejmijOdwrotnie(Stała w) { return twórz(w.wart-this.wart); }
    public Wyrazenie pomnóż(Stała w) { return twórz(this.wart*w.wart); }
    public Wyrazenie pomnóş(Wyrazenie w) { return w.pomnóşOdwrotnie(this); }
    Wyrazenie pomnóżOdwrotnie(Stała w) { return twórz(w.wart*this.wart); }
    public Wyrazenie podziel(Stała w) { return twórz(this.wart/w.wart); }
    public Wyrazenie podziel(Wyrazenie w) { return w.podzielOdwrotnie(this); }
    Wyrazenie podzielOdwrotnie(Stała w) { return twórz(w.wart/this.wart); }

    public Wyrazenie pochodna() { return Zero.twĂłrz(); }
}

class Zero extends Stała {
    private static final Zero ZERO=new Zero();
    private Zero() { super(0.0); }
    public static Zero twĂłrz() { return ZERO; }

    public Wyrazenie dodaj(Wyrazenie w) { return w; }
    Wyrazenie dodajOdwrotnie(Wyrazenie w) { return w; }
    Wyrazenie odejmijOdwrotnie(Wyrazenie w) { return w; }
    public Wyrazenie pomnóş(Wyrazenie w) { return this; }
    Wyrazenie pomnóşOdwrotnie(Wyrazenie w) { return this; }
    public Wyrazenie podziel(Wyrazenie w) { return this; }
}

class Jeden extends Stała {
    private static final Jeden JEDEN=new Jeden();
    private Jeden() { super(1.0); }
    public static Jeden twĂłrz() { return JEDEN; }
    public Wyrazenie pomnóş(Wyrazenie w) { return w; }
    Wyrazenie pomnóşOdwrotnie(Wyrazenie w) { return w; }
    Wyrazenie podzielOdwrotnie(Wyrazenie w) { return w; }
}

class Zmienna extends Wyrazenie {
    private static final Zmienna X=new Zmienna();
    private Zmienna() { }
    public static Zmienna twĂłrz() { return X; }
    public String toString() { return "x"; }
    public double wartość(double x) { return x; }

    public Wyrazenie pochodna() { return Jeden.twĂłrz(); }
}

abstract class Wyr2Arg extends Wyrazenie {
    protected final Wyrazenie arg1;
    protected final Wyrazenie arg2;

    Wyr2Arg(Wyrazenie arg1, Wyrazenie arg2) {
        this.arg1 = arg1;
        this.arg2 = arg2;
    }
    abstract String znakOp();
    public String toString() {
        String res = "";
        if (this.priorytet() > arg1.priorytet())
            res +="("+this.arg1+")";
        else
            res += this.arg1;

        res += znakOp();

        if (this.priorytet() >= arg2.priorytet())
            res +="("+this.arg2+")";
        else
            res += this.arg2;
        return res;
    }
}

abstract class Wyr1Arg extends Wyrazenie {
    protected final Wyrazenie arg;

    Wyr1Arg(Wyrazenie arg) {
        this.arg = arg;
    }
    abstract String znakOp();
    public String toString() { return znakOp()+"("+this.arg+")"; }
}

class Plus extends Wyr2Arg {
    Plus(Wyrazenie arg1, Wyrazenie arg2) { super(arg1, arg2); }
    String znakOp() { return "+"; }
    public double wartość(double x) { return arg1.wartość(x)+arg2.wartość(x); }
    int priorytet() { return 100; }

    public Wyrazenie pochodna() { return arg1.pochodna().dodaj(arg2.pochodna()); }
}

class Minus extends Wyr2Arg {
    Minus(Wyrazenie arg1, Wyrazenie arg2) { super(arg1, arg2); }
    String znakOp() { return "-"; }
    public double wartość(double x) { return arg1.wartość(x)-arg2.wartość(x); }
    int priorytet() { return 100; }

    public Wyrazenie pochodna() { return arg1.pochodna().odejmij(arg2.pochodna()); }
}

class Razy extends Wyr2Arg {
    Razy(Wyrazenie arg1, Wyrazenie arg2) { super(arg1, arg2); }
    String znakOp() { return "*"; }
    public double wartość(double x) { return arg1.wartość(x)*arg2.wartość(x); }
    int priorytet() { return 1000; }

    public Wyrazenie pochodna() {
        return arg1.pochodna().pomnóş(arg2)
            .dodaj(arg1.pomnóş(arg2.pochodna()));
    }
}

class Dzielenie extends Wyr2Arg {
    Dzielenie(Wyrazenie arg1, Wyrazenie arg2) { super(arg1, arg2); }
    String znakOp() { return "/"; }
    public double wartość(double x) { return arg1.wartość(x)/arg2.wartość(x); }
    int priorytet() { return 1000; }

    public Wyrazenie pochodna() {
        return arg1.pochodna().pomnóş(arg2)
            .odejmij(arg1.pomnóş(arg2.pochodna()))
            .podziel(arg1.pomnóş(arg1));
    }
}

class MinusUnarny extends Wyr1Arg {
    public MinusUnarny(Wyrazenie arg) { super(arg); }
    String znakOp() { return "-"; }
    public double wartość(double x) { return -(arg.wartość(x)); }
    public Wyrazenie pochodna() { return new MinusUnarny(arg.pochodna()); }
}


class Cos extends Wyr1Arg {
    public Cos(Wyrazenie arg) { super(arg); }
    String znakOp() { return "cos"; }
    public double wartość(double x) { return Math.cos(arg.wartość(x)); }
    public Wyrazenie pochodna() { return new MinusUnarny(new Sin(arg)); }
}

class Sin extends Wyr1Arg {
    public Sin(Wyrazenie arg) { super(arg); }
    String znakOp() { return "sin"; }
    public double wartość(double x) { return Math.sin(arg.wartość(x)); }
    public Wyrazenie pochodna() { return new Cos(arg); }
}