I have a function to generate a (pseudo) random walk on a square lattice where the walk should not breach the boundaries of this square, full function below:

```
/**
* @brief Performs a single random walk returning the final distance from the origin
*
* Completes a random walk on a square lattice using the mersenne twister engine based pseudo-random
* number-generator (PRNG). The walk will not breach the boundaries of the square size provided to
* the function. The random walk starts at the origin and ends after some parameterised number of steps.
* Position co-ordinates of the walk for each iteration are sent to an output file.
*
* @param squareSideLength Length of square lattice side
* @param steps Number of steps to compute random walk up to
* @param engine Mersenne Twister engine typedef (used for generating random numbers locally)
* @param distribution Default distribution of random walk
* @param outputFile [Default nullptr] Pointer to file to write co-ordinate data of random walk to
* @return final distance of the particle from the origin
*/
double randomWalkSquareLattice(int squareSideLength, int steps, std::mt19937& engine, std::uniform_real_distribution<double>& distribution, std::ofstream* outputFile = nullptr) {

    // store the half-length of the square lattice
    const int halfSquareLength = squareSideLength / 2;

    // initialise co-ordinates to the origin
    double positionX = 0.0;
    double positionY = 0.0;

    // assign the default distribution to distDefault
    std::uniform_real_distribution<double> distDefault = distribution;

    // loop over a number of iterations given by the steps parameter
    for (int i = 0; i < steps; i++) {

        std::cout << positionX << "\t" << positionY << std::endl;

        // if the x-position of the particle is >= to positive
        // half square lattice length then generate decremental 
        // random number (avoiding breaching the boundary)
        if (positionX >= halfSquareLength) {
            double offset = positionX - halfSquareLength;
            std::cout << std::endl << offset << std::endl;
            std::uniform_real_distribution<double> distOffset(-offset, -1.0);
            positionX += distOffset(engine);
        }

        // else if the x-position of the particle is <= to negative
        // half square lattice length then generate incremental random
        // number (avoiding breaching the boundary)
        else if (positionX <= -halfSquareLength) {
            double offset = std::abs(positionX + halfSquareLength);
            std::cout << std::endl << offset << std::endl;
            std::uniform_real_distribution<double> distOffset(offset, 1.0);
            positionX += distOffset(engine);
        }

        // else (in case where x-position of particle is not touching 
        // the lattice boundary) generate default random number
        else {
            positionX += distDefault(engine);
        }

        // if the y-position of the particle is >= to positive
        // half square lattice length then generate decremental 
        // random number (avoiding breaching the boundary)
        if (positionY >= halfSquareLength) {
            double offset = positionY - halfSquareLength;
            std::cout << std::endl << offset << std::endl;
            std::uniform_real_distribution<double> distOffset(-offset, -1.0);
            positionY += distOffset(engine);
        }

        // else if the y-position of the particle is <= to negative
        // half square lattice length then generate incremental 
        // random number (avoiding breaching the boundary)
        else if (positionY <= -halfSquareLength) {
            double offset = std::abs(positionY + halfSquareLength);
            std::cout << std::endl << offset << std::endl;
            std::uniform_real_distribution<double> distOffset(offset, 1.0);
            positionY += distOffset(engine);
        }

        // else (in case where y-position of particle is not touching
        // the lattice boundary) generate default random number
        else {
            positionY += distDefault(engine);
        }

        // if an outputFile is supplied to the function, then write data to it
        if (outputFile != nullptr) {
            *outputFile << positionX << "\t" << positionY << std::endl;
        }

    }

    // compute final distance of particle from origin
    double endDistance = std::sqrt(positionX*positionX + positionY*positionY);

    return endDistance;

}

```

Where the conditionals seen in the method prevent the walk exiting the boundaries. However, when this is called with a sufficient number of steps (so that any one of these conditionals is executed) I get an error saying:

```
invalid min and max arguments for uniform_real

```

Note that the dist I send to this function is:

```
std::uniform_real_distribution<double> dist(-1.0,1.0);

```

And so (as you can see from the values printed to the terminal) the issue is not that the offset will ever be larger than the max value given to the distOffset in any of the conditional cases.

Is the issue that I cannot give u\_r\_d a double value of arbitrary precision? Or is something else at play here that I am missing?

Edit: I should add that these are the values used in main():

```
int main(void) {
    std::uniform_real_distribution<double> dist(-1.0, 1.0);

    std::random_device randDevice;

    std::mt19937 engine(randDevice());
    //std::cout << dist(engine) << std::endl;
    // Dimensions of Square Lattice
    const int squareLength = 100;

    // Number of Steps in Random Walk
    const int nSteps = 10000;

    randomWalkSquareLattice(squareLength, nSteps, engine, dist);
}

```