Policzenie wszystkich kombinacji liczby danej wzorem

#include <iostream>
#include <iomanip>
using namespace std;
//#include <conio>
#include <string>
#include <vector>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <gmp.h>
#include <gmpxx.h>

//====================================================================================================================

void computeW( mpf_class & w, int pX, int pY, int pP, const vector < vector < int >>& pXn, const vector < int >& pXIndxs );
bool isNaturalNum( mpf_class w );

//====================================================================================================================


int main()
{
   
    mpf_set_default_prec( 1000 );
   
   
    long long p;
    int y;
    int x;
   
    cout << "Podaj p: ";
    cin >> p;
    cout << "Podaj y: ";
    cin >> y;
    cout << "Podaj x: ";
    cin >> x;
   
    vector < vector < int > > xn( y - 1, vector < int >( x + 1 ) );
   
    for( auto & vec: xn )
    {
        for( int i = 0; i <= x; ++i )
        {
            vec[ i ] = i;
        }
    }
   
    vector < int > xIndxs( xn.size(), 0 );
    mpf_class w;
    // mpf_init(w);
   
    bool exit = false;
    double counter = 0;
    unsigned long long howManyFound = 0;
   
    cout << "Start " << endl;
   
    while( !exit )
    {
        counter++;
       
        computeW( w, x, y, p, xn, xIndxs );
        // if( isNaturalNum( w ) )
        if( w = w )
        {
            ++howManyFound;
           
            cout << "w = " << fixed << w << "; ";
            for( int i = 0; i < xn.size(); ++i )
            {
                cout << "x" << i + 1 << "=" << xn[ i ][ xIndxs[ i ] ] <<( i == xn.size() - 1 ? ""
                    : ", " );
            }
            cout << endl;
        }
       
        ++xIndxs[ 0 ];
       
        for( int j = xIndxs.size() - 1; j > 0; --j )
        {
            if( xIndxs[ j ] == x )
            {
                if( j == xIndxs.size() - 1 ) { exit = true; break; }
               
                ++xIndxs[ j + 1 ];
               
                for( int pom = j; pom >= 0; --pom )
                {
                    xIndxs[ pom ] = xIndxs[ j + 1 ];
                }
               
                break;
            }
        }
       
        if( xIndxs[ 0 ] == x + 1 )
        {
            if( xIndxs.size() >= 2 )
            {
                ++xIndxs[ 1 ];
                xIndxs[ 0 ] = xIndxs[ 1 ];
            }
            else
            {
                exit = true;
            }
        }
    }
   
    cout << "Koniec" << endl;
    cout << "wszystkich iteracji: " << fixed << setprecision( 0 ) << counter << endl;
    cout << "Policzonych liczb w: " << howManyFound << endl;
    if( pow( 2, y + x ) - pow( p, y ) < 0 )
    {
        cout << "Ujemne" << endl;
    }
   
    getchar();
    return 0;
}
//====================================================================================================================
void computeW( mpf_class & w, int pX, int pY, int pP, const vector < vector < int > >& pXn, const vector < int >& pXIndxs )
{
   
    mpz_class pow1, pow2, pow3;
    mpf_class tmpf;
   
    w = 0;
   
    for( int i = 0; i < pXn.size(); ++i )
    {
        mpz_ui_pow_ui( pow1.get_mpz_t(), 2, pXn[ i ][ pXIndxs[ i ] ] );
        mpz_ui_pow_ui( pow2.get_mpz_t(), pP, i );
        mpz_ui_pow_ui( pow3.get_mpz_t(), 2, i );
       
       
        tmpf = pow1 * pow2;
        tmpf /= pow3;
        w += tmpf;
    }
   
    mpz_ui_pow_ui( pow1.get_mpz_t(), pP, pY - 1 );
    mpz_ui_pow_ui( pow2.get_mpz_t(), 2, pY - 1 );
    tmpf = pow1;
    w += tmpf / pow2;
   
    mpz_ui_pow_ui( pow1.get_mpz_t(), 2, pY - 1 );
    w *= pow1;
   
    mpz_ui_pow_ui( pow1.get_mpz_t(), 2, pX + pY );
    mpz_ui_pow_ui( pow2.get_mpz_t(), pP, pY );
   
    //w /= abs(pow1 - pow2);
    w /= abs( 1 );
}

//*****************************************************************************
bool isNaturalNum( mpf_class w )
{
    return mpf_integer_p( w.get_mpf_t() );
}
//*****************************************************************************