Серия случайных блужданий между начальными и конечными значениями и в пределах минимальных/максимальных пределов

Поскольку вы накладываете условия на свою прогулку, ее нельзя считать чисто случайной. В любом случае, один из способов — генерировать обход итеративно и проверять границы на каждой итерации. Но если вам нужно векторное решение, вот оно:

def bounded_random_walk(length, lower_bound,  upper_bound, start, end, std):
    assert (lower_bound <= start and lower_bound <= end)
    assert (start <= upper_bound and end <= upper_bound)

    bounds = upper_bound - lower_bound

    rand = (std * (np.random.random(length) - 0.5)).cumsum()
    rand_trend = np.linspace(rand[0], rand[-1], length)
    rand_deltas = (rand - rand_trend)
    rand_deltas /= np.max([1, (rand_deltas.max()-rand_deltas.min())/bounds])

    trend_line = np.linspace(start, end, length)
    upper_bound_delta = upper_bound - trend_line
    lower_bound_delta = lower_bound - trend_line

    upper_slips_mask = (rand_deltas-upper_bound_delta) >= 0
    upper_deltas =  rand_deltas - upper_bound_delta
    rand_deltas[upper_slips_mask] = (upper_bound_delta - upper_deltas)[upper_slips_mask]

    lower_slips_mask = (lower_bound_delta-rand_deltas) >= 0
    lower_deltas =  lower_bound_delta - rand_deltas
    rand_deltas[lower_slips_mask] = (lower_bound_delta + lower_deltas)[lower_slips_mask]

    return trend_line + rand_deltas

randomData = bounded_random_walk(1000, lower_bound=50, upper_bound =100, start=50, end=100, std=10)

Вы можете видеть это как решение геометрической задачи. trend_line соединяет ваши точки start и end и имеет поля, определяемые lower_bound и upper_bound. rand — ваше случайное блуждание, rand_trend — линия тренда и rand_deltas — отклонение от rand линии тренда. Мы совмещаем линии тренда и хотим убедиться, что дельты не превышают поля. Когда rand_deltas превышает допустимое поле, мы «складываем» лишнее обратно к границам.

В конце вы добавляете полученные случайные дельты к линии тренда start=>end, таким образом получая желаемое ограниченное случайное блуждание.

Параметр std соответствует величине дисперсии случайного блуждания.

обновление: исправлены утверждения

В этой версии "std" не обещает быть "интервалом".

Я заметил, что вы использовали встроенные функции в качестве аргументов (min и max), что не рекомендуется (я изменил их на max_1 и min_1). Кроме этого, ваш код должен работать так, как ожидалось:

def generateRandomData(length,randomPerc, min_1,max_1,start, end):
    data_np = (np.random.random(length) - randomPerc).cumsum()
    data_np *= (max_1 - min_1) / (data_np.max() - data_np.min())
    data_np += np.linspace(start - data_np[0], end - data_np[-1],len(data_np))
    return data_np
randomData=generateRandomData(1000, 0.5, 50, 100, 66, 80)

Если вы хотите изменить свой код, это будет работать:

import random
for_fill=[]
# generate 1000 samples within the specified range and save them in for_fill
for x in range(1000):
    generate_rnd_df=random.uniform(50,100)
    for_fill.append(generate_rnd_df)
#set starting and end point manually
for_fill[0]=60
for_fill[999]=80

Вот один из способов, очень грубо выраженный в коде.

>>> import random
>>> steps = 1000
>>> start = 66
>>> end = 80
>>> step_size = (50,100)

Создайте 1000 шагов, гарантированно находящихся в требуемом диапазоне.

>>> crude_walk_steps = [random.uniform(*step_size) for _ in range(steps)]
>>> import numpy as np

Превратите эти шаги в прогулку, но обратите внимание, что они не соответствуют требованиям.

>>> crude_walk = np.cumsum(crude_walk_steps)
>>> min(crude_walk)
57.099056617839288
>>> max(crude_walk)
75048.948693623403

Рассчитайте простое линейное преобразование для масштабирования шагов.

>>> from sympy import *
>>> var('a b')
(a, b)
>>> solve([57.099056617839288*a+b-66,75048.948693623403*a+b-80])
{b: 65.9893403510312, a: 0.000186686954219243}

Масштабирует шаги.

>>> walk = [0.000186686954219243*_+65.9893403510312 for _ in crude_walk]

Убедитесь, что прогулка теперь начинается и останавливается там, где предполагалось.

>>> min(walk)
65.999999999999986
>>> max(walk)
79.999999999999986

Вы также можете создать поток случайных блужданий и отфильтровать те, которые не соответствуют вашим ограничениям. Просто имейте в виду, что при фильтрации они больше не являются «случайными».

Код ниже создает бесконечный поток «действительных» случайных блужданий. Будьте осторожны с очень жесткими ограничениями, «следующий» вызов может занять некоторое время;).

import itertools
import numpy as np


def make_random_walk(first, last, min_val, max_val, size):
    # Generate a sequence of random steps of lenght `size-2`
    # that will be taken bewteen the start and stop values.
    steps = np.random.normal(size=size-2)

    # The walk is the cumsum of those steps
    walk = steps.cumsum()

    # Performing the walk from the start value gives you your series.
    series = walk + first

    # Compare the target min and max values with the observed ones.
    target_min_max = np.array([min_val, max_val])
    observed_min_max = np.array([series.min(), series.max()])

    # Calculate the absolute 'overshoot' for min and max values
    f = np.array([-1, 1])
    overshoot = (observed_min_max*f - target_min_max*f)

    # Calculate the scale factor to constrain the walk within the
    # target min/max values.
    # Don't upscale.
    correction_base = [walk.min(), walk.max()][np.argmax(overshoot)]
    scale = min(1, (correction_base - overshoot.max()) / correction_base)

    # Generate the scaled series
    new_steps = steps * scale
    new_walk = new_steps.cumsum()
    new_series = new_walk + first

    # Check the size of the final step necessary to reach the target endpoint.
    last_step_size = abs(last - new_series[-1]) # step needed to reach desired end

    # Is it larger than the largest previously observed step?
    if last_step_size > np.abs(new_steps).max():
        # If so, consider this series invalid.
        return None
    else:
        # Else, we found a valid series that meets the constraints.
        return np.concatenate((np.array([first]), new_series, np.array([last])))


start = 66
stop = 80
max_val = 100
min_val = 50
size = 1000

# Create an infinite stream of candidate series
candidate_walks = (
    (i, make_random_walk(first=start, last=stop, min_val=min_val, max_val=max_val, size=size))
    for i in itertools.count()
)
# Filter out the invalid ones.
valid_walks = ((i, w) for i, w in candidate_walks if w is not None)

idx, walk = next(valid_walks)  # Get the next valid series
print(
    "Walk #{}: min/max({:.2f}/{:.2f})"
    .format(idx, walk.min(), walk.max())
)