pochodna z pochodnej

#include <iostream>
#include <math.h>
#include <vector>
//#include <cmath>

using namespace std;
double funkcja(double x)
{
    //return sin(x);
    //return tan(x);
    //return 6*pow(x, 5) - 12*pow(x, 3) + pow(x, 2) - 8*x;
    //return (-1)/x + sin(x);
    //return tan(x)*tan(x)-x;
    //return 1/sin(x);
    //return sin(1/x);
    //return -pow(x,2) - sin(x) + 0.98;
    //return 12*x*x - 10*x - 6.9815;
    return log(x+1)-2*x*x+1;

}

double pochodna(double x)
{
    //return cos(x);
    //return 2/(cos(2*x) + 1); //tan(x)
    //return 2*(15*pow(x,4) - 18*pow(x,2) + x - 4);
    //return 1/pow(x,2) + cos(x);
    //return 2*tan(x)*(1/cos(x))*(1/cos(x)) -1;
    //return 2*cos(x)/(cos(2*x) - 1);
    //return -cos(1/x)/(x*x);
    //return -2*x - cos(x);
    //return 24*x - 10;
    return -4*x + 1/(x+1);
}

double druga_pochodna(double x)
{
    //return 0;
    //return funkcja(x)*pochodna(x)*2; //tan(x)
    //return 120*pow(x,3) -72*x + 2;
    //return (2*x*cos(1/x) - sin(1/x))/pow(x,4); //sin(1/x)
    //return 24;
    return -4 -1/((x+1)*(x+1));
}

struct przedzial
{
    double a;
    double b;
};
int main()
{
    double epsilon = 1e-1;
    double a=-5;
    double b=5;
    //double krok = (double)(b-a)/100000.0; //1000 przedzialow, musi starczyc
    double krok = 1e-1;
    int N=100000;
    cout.precision(50);
    //najpierw wyznaczymy przedzialy izolacji pierwiastkow pomiedzy a i b
    vector<przedzial> p_i;
    //p_i to przedzialy izolacji
    double aa=a;
    double bb=a+krok;
    double fa=0;
    double fb=funkcja(aa);
    double m;
    przedzial znaleziony;
    bool asym = false;
    int i;
    while(bb<=b)
    {
        fa=fb;
        fb=funkcja(bb);
        if( (double)(fa*fb) <= 0.0)
        {
            znaleziony.a = aa;
            znaleziony.b = bb;
            if(funkcja(aa) != 0.0)
                p_i.push_back(znaleziony);
            //bo nie chcemy miec 2 razy
        }
        aa=bb;
        bb+=krok;
    }

    for(int eps=0; eps<15; eps++)
    {
    //metoda bisekcji
    for(int j=0; j<p_i.size(); j++)
    {
        double x1;// p_i[j].a + (double)(((double)p_i[j].b-(double)p_i[j].a)/2.0);
        aa=p_i[j].a;
        bb=p_i[j].b;
        for(i=0; i<N; i++)
        {

            x1= aa + ((bb-aa)/2.0);
            //piekne warunki w ifie, monotonicznosc sprawdzamy.
            if(!(( (funkcja(aa) <= funkcja(x1)) && (funkcja(x1) <= funkcja(bb)) )||( (funkcja(aa) >= funkcja(x1)) && (funkcja(x1) >= funkcja(bb) ) )))
            {
                asym=true;
                cout << "asym\n";
                break;
            }

            if( funkcja(aa)*funkcja(x1) < 0)
            {
                //aa bez zmian
                bb = x1;
            }
            else
            {
                aa =x1;
                //bb bez zmian
            }
            if((abs(funkcja(x1)) < epsilon) && (abs(aa-bb) < epsilon))
                break;
        }
        if(asym==false)
            cout << x1 << " "<< i <<"\n";
        else
            asym=false;
    }

    //cout << "\n";
    //metoda stycznych
    for(int j=0; j<p_i.size(); j++)
    {
        double x1;
        if((funkcja(p_i[j].a)*druga_pochodna(p_i[j].a)) > 0)
            x1 = p_i[j].a;
        else
            x1 = p_i[j].b;
        m = min(pochodna(p_i[j].a), pochodna(p_i[j].b));
        for(i=0; i<N; i++)
        {
            if(pochodna(x1) == 0)
            {
                cout << "pochodna jest zerem\n";
                break;
            }
            else
            {
                x1 = x1 - funkcja(x1)/pochodna(x1);
                //if(!(x1 >= p_i[j].a && x1 <= p_i[j].b))
                if(x1 < p_i[j].a || x1 > p_i[j].b)
                {
                    cout << "asymptopta\n";
                    asym=true;
                    break;
                }

            }
            if(abs(funkcja(x1)/m) < epsilon)
                break;
        }
        if(asym == false)
            cout << x1 << " "<< i <<"\n";
        else
            asym=false;
    }
    epsilon = epsilon/10;
    }
    return 0;
}