Ошибка -nan при вызове математического выражения

Float quanc(Float x){
  return (1-exp(-0.8*x))/(x+1.6*x*x);
}
 
void findA(Float A){
  int nofR=0;
  Float a=0.0;
  Float b=1.0;
  Float errR=0;
  Float abser=0;
  Float relerr=1.0e-10;
  A=Q(quanc,a,b,abser,relerr,&errR,&nofR,&flag);
  //A=(Aa-0.40874702)*(Aa-0.40874702)*(Aa-0.40874702)*(Aa-0.40874702);
  cout << "Value program Q: A= " << A << " flag=" << flag << endl;
}
 
int main(){
  findA(A);
}

#include "forsythe.h"
#include <math.h>
 
Float Quanc8(Float (*F)(Float), Float a, Float b, Float ae, Float re, Float *errest, int *nofun, Float *flag)
{
    const Float w0 = (Float)3956/(Float)14175,
                w1 = (Float)23552/(Float)14175,
                w2 = (Float)(-3712)/(Float)14175,
                w3 = (Float)41984/(Float)14175,
                w4 = (Float)(-18160)/(Float)14175;
    Float result = 0.0, area = 0.0, x0 = a, f0, stone = (b-a)/(Float)16, step, cor11 = 0.0, qprev = 0.0, qnow, qdiff, qleft, esterr, tolerr,
        qright[31], f[16], x[16], fsave[8][30], xsave[8][30];
 
    //*** ЭТАП 1 *** Присвоение начальных значений переменным, не зависящим от интервала. Генерирование констант.
    #define LEVMIN  1
    #define LEVMAX  30
    #define LEVOUT  6
    #define NOMAX   5000
    int levmax = LEVMAX, nofin = NOMAX - 8*(LEVMAX-LEVOUT+(1<<(LEVOUT+1))),//Если '*nofun' достигает значения 'nofin', то тревога
        lev = 0, nim = 1, i, j;
 
    //Присвоить нулевые значения переменным суммам
    *flag = 0.0;
    *errest = 0.0;
    *nofun = 0;
 
    if(a == b) return 0.0;
 
    //*** ЭТАП 2 *** Присвоение начальных значений переменным, зависящим от интервала, в соответствии с первым интервалом
    x[15] = b;
    f0 = F(x0);
    x[7] = (x0+b)/(Float)2;
    x[3] = (x0+x[7])/(Float)2;
    x[11] = (x[7]+b)/(Float)2;
    x[1] = (x0+x[3])/(Float)2;
    x[5] = (x[3]+x[7])/(Float)2;
    x[9] = (x[7]+x[11])/(Float)2;
    x[13] = (x[11]+b)/(Float)2;
 
    for(j=1;j<=15;j+=2) f[j] = F(x[j]);
    *nofun = 9;
 
    //*** ЭТАП 3 *** Основные вычисления
    while(1)
    {
        x[0] = (x0+x[1])/(Float)2;
        f[0] = F(x[0]);
        for(j=2;j<=14;j+=2)
        {
            x[j] = (x[j-1]+x[j+1])/(Float)2;
            f[j] = F(x[j]);
        }
        nofun += 8;
        step = (x[15]-x0)/(Float)16;
        qleft = (w0*(f0+f[7]) + w1*(f[0]+f[6]) + w2*(f[1]+f[5]) + w3*(f[2]+f[4]) + w4*f[3]) * step;
        qright[lev] = (w0*(f[7]+f[15]) + w1*(f[8]+f[14]) + w2*(f[9]+f[13]) + w3*(f[10]+f[12]) + w4*f[11]) * step;
        qnow = qleft + qright[lev];
        qdiff = qnow - qprev;
        area += qdiff;
 
        //*** ЭTAП 4 *** Проверка сходимости для интервала
        esterr = ABS(qdiff)/(Float)1023;
        tolerr = MAX(ae, re*ABS(area))*(step/stone);
 
        if(lev < LEVMIN || ((lev < levmax) && (*nofun <= nofin) && (esterr > tolerr)))
        {
            //*** ЭTAП 5 *** Сходимости нет. Установить следующий интервал
            nim <<= 1;
            lev++;
            //Запомнить элементы, относящиеся к правой половине интервала, для будущего использования
            for(i=0;i<8;i++)
            {
                fsave[i][lev-1] = f[i+8];
                xsave[i][lev-1] = x[i+8];
            }
            //Собрать элементы, относящиеся к левой половине интервала для немедленного использования
            qprev = qleft;
            for(i=7;i>=0;i--)
            {
                f[i*2+1] = f[i];
                x[i*2+1] = x[i];
            }
            continue;
        }
 
        if(lev >= levmax) *flag += (Float)1.0;
        else if(*nofun > nofin)
        {
            nofin <<= 1;
            levmax = LEVOUT;
            *flag += (b-x0)/(b-a);
            //Текущее предельное значение глубины деления пополам равно 'levmax'
        }
 
        //*** ЭTAП 7 *** Сходимость для интервала имеет место. Прибавить очередные слагаемые к переменным суммам
        result += qnow;
        *errest += esterr;
        cor11 += qdiff/(Float)1023;
 
        //Установить следующий интервал
        while(nim & 1)//если nim - нечётное
        {
            nim /= 2;
            lev--;
        }
        nim++;
        if(lev <= 0) break;
 
        //Собрать элементы, необходимые для следующего интервала
        qprev = qright[lev-1];
        x0 = x[15];
        f0 = f[15];
        for(i=0;i<8;i++)
        {
            f[i*2+1] = fsave[i][lev-1];
            x[i*2+1] = xsave[i][lev-1];
        }
    }
 
    //*** ЭTAП 8 *** Заключительные операции и выход
    result += cor11;
    //Обеспечить, чтобы значение переменной '*errest' было не меньше уровня округлений
    if(*errest == (Float)0.0) return result;
    Float temp;
    while(1)
    {
        temp = ABS(result) + *errest;
        if(temp != ABS(result)) return result;
        *errest *= (Float)2;
    }
}

#ifndef __FORSYTHE_H__
#define __FORSYTHE_H__
 
#include <float.h>
 
#define FT_FLOAT    0   //'float'
#define FT_DOUBLE   1   //'double'
#define FT_LDOUBLE  2   //'long double'
 
//Здесь можно переопределить вещественный тип, который будет использоваться в вычислениях.
//Если важна скорость - используйте 'float' (т.е. FT_FLOAT), если нужна точность - используйте 'double' (FT_DOUBLE)
//или 'long double' (FT_LDOUBLE).
#define FLOATTYPE   FT_DOUBLE
 
#if FLOATTYPE == FT_FLOAT
    typedef float Float;
    #define EPSILON FLT_EPSILON
    #define MAXIMUM FLT_MAX
#elif FLOATTYPE == FT_DOUBLE
    typedef double Float;
    #define EPSILON DBL_EPSILON
    #define MAXIMUM DBL_MAX
#elif FLOATTYPE == FT_LDOUBLE
    typedef long double Float;
    #define EPSILON LDBL_EPSILON
    #define MAXIMUM LDBL_MAX
#else
    #error Invalid Float Type
#endif
 
//Некоторые полезные макросы
#define ABS(x) (((x) >= 0) ? (x) : -(x))
#define MAX(x, y) (((x) >= (y)) ? (x) : (y))
#define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define SIGN0(x) (((x) > 0) ? 1 : -1)
#define SIGN(x) (((x) == 0) ? 0 : SIGN0(x))
#define SIGN2(a, b) (SIGN(b)*ABS(a))
 
 
Float Quanc8(Float (*F)(Float), Float a, Float b, Float ae, Float re, Float *errest, int *nofun, Float *flag);

Float quanc(Float x){
  if(x==0)return 1.0;
  return (1-exp(-0.8*x))/(x+1.6*x*x);
}