void fast_conv(const double *pSigA, unsigned int uSizeA, const double *pSigB,unsigned int uSizeB, double *pSigR){
    complex<double>    *pSigACx, *pSigBCx;
    size_t i;

    uint uConvSize = get_length(uSizeA + uSizeB - 1);
    
    pSigACx = new complex<double>[uConvSize];
    pSigBCx = new complex<double>[uConvSize];

    for(i = 0; i != uSizeA; i++){
        pSigACx[i] = complex<double>(pSigA[i], 0.0);
    }

    for(i = uSizeA; i != uConvSize; i++){
        pSigACx[i] = complex<double>(0.0, 0.0);
    }

    fft(pSigACx, uConvSize, false);

    for(i = 0; i != uSizeB; i++){
        pSigBCx[i] = complex<double>(pSigB[i], 0.0);
    }

    for(i = uSizeB; i != uConvSize; i++){
        pSigBCx[i] = complex<double>(0.0, 0.0);
    }

    fft(pSigBCx, uConvSize, false);

    for(i = 0; i != uConvSize; i++){
        pSigACx[i] *= pSigBCx[i];
    }

    fft(pSigACx, uConvSize, true);

    for(i = 0; i != uSizeA; i++){
        pSigR[i] = pSigACx[i].real();
    }

    delete [] pSigACx;
    delete [] pSigBCx;
}

uint uConvSize = get_length(uSizeA + uSizeB - 1);

uint uConvSize = uSizeA + uSizeB - 1;

for(i = 0; i != uSizeA; i++)

//быстрая свертка
void COOLibin_math::fastconvolution(std::vector<double>& Signal,
                                const std::vector<double>& Responce,
                                uint uPositiveLen)
{
    std::vector<std::complex<double> >    SignalCx, ResponceCx;
    uint uConvLen, uSignalLen, uNegativeLen;
    size_t i;

    uSignalLen = Signal.size();
    uNegativeLen = Responce.size() - uPositiveLen - 1;

    uConvLen = uSignalLen;
    if(uNegativeLen > uPositiveLen ){
        uConvLen += uNegativeLen;
    }
    else{
        uConvLen += uPositiveLen;
    }

    if( uNegativeLen + uPositiveLen + 1 > uConvLen ){
        uConvLen = uNegativeLen + uPositiveLen + 1;
    }

    i = 1;
    while(i < uConvLen)
    {
        i = i*2;
    }
    uConvLen = i;

    SignalCx.resize(uConvLen);
    ResponceCx.resize(uConvLen);

    for(i = 0; i != uSignalLen; i++){
        SignalCx[i] = std::complex<double>(Signal[i], 0.0);
    }

    for(i = uSignalLen; i != uConvLen; i++){
        SignalCx[i] = std::complex<double>(0.0, 0.0);
    }

    for(i = 0; i != uConvLen; i++){
        ResponceCx[i] = std::complex<double>(0.0, 0.0);
    }

    for(i = 0; i <= uPositiveLen; i++){
        ResponceCx[i] = std::complex<double>(Responce[i + uNegativeLen], 0.0);
    }

    for(i = 1; i <= uNegativeLen; i++){
        ResponceCx[uConvLen - i] = std::complex<double>(Responce[uNegativeLen - i], 0.0);
    }

    fft(SignalCx, false);
    fft(ResponceCx, false);

    for(i = 0; i != uConvLen; i++){
        SignalCx[i] *= ResponceCx[i];
    }

    fft(SignalCx, true);

    for(i = 0; i != uSignalLen; i++){
        Signal[i] = SignalCx[i].real();
    }
}

void COOLibin_math::rec_fft(std::vector<std::complex<double> >& Signal,
                                        bool bInv){

    uint uSignalLen = Signal.size();
    if(uSignalLen == 1){
        return;
    }

    const double    PI = 3.1415926535897932;
    std::vector<std::complex<double> >    Odd(uSignalLen/2), Even(uSignalLen/2);

    for(size_t i = 0; i != uSignalLen/2; i++){
            Odd[i] = Signal[2*i];
            Even[i] = Signal[2*i + 1];
    }

    rec_fft(Odd, bInv);
    rec_fft(Even, bInv);

    double fSign;
    if(!bInv){
        fSign = 1.0;
    }
    else{
        fSign = -1.0;
    }

    std::complex<double> W(1.0, 0.0), WStep(cos(2.0*PI/uSignalLen), sin(fSign*2.0*PI/uSignalLen)), Temp;

    for(size_t k = 0; k != uSignalLen/2; k++){
        Temp = W*Even[k];
        Signal[k] = Odd[k] + Temp;
        Signal[k + uSignalLen/2] = Odd[k] - Temp;
        W *= WStep;
    }
}



void COOLibin_math::fft(std::vector<std::complex<double> >& Signal,
                                        bool bInv){

    rec_fft(Signal, bInv);

    if(bInv){
         uint uSignalLen = Signal.size();
         for(std::vector<std::complex<double> >::iterator it = Signal.begin(); it != Signal.end(); it++){
               (*it) /= uSignalLen;
         }
     }
}