是否有（一个）单调非递减噪声函数？

我想要一个函数，该函数可以使对象随时间从A点移动到B点，以使其在某个固定时间到达B点，但是它在任何时候的位置都会以连续的方式随机地受到扰动，但是永远不会向后退。对象沿直线移动，所以我只需要一个维度。

从数学上讲，这意味着我正在寻找一些连续的f（x），x∈[0,1]，使得：

• f（0）= 0
• f（1）= 1
• x <y→f（x）≤f（y）
• 在“最”点，f（x + d）-f（x）与d没有明显关系。（该函数不是均匀增加的或不可预测的；我认为这也等同于说没有导数是常数。）

理想情况下，我实际上希望以某种方式拥有这些功能的族，提供某种种子状态。对于我当前的使用，我至少需要4位种子（16个可能的函数），但是由于没有太多的余地提供更多。

为了避免误差积累的各种问题，我宁愿功能并不需要任何的内部状态。也就是说，我希望它是一个真正的功能，而不是编程的“功能”。

对于此帖子，y = f（t），其中t是您要更改的参数（时间/进度），y是到目标的距离。因此，我将根据2D绘图上的点进行发言，其中水平轴是时间/进度，垂直轴是距离。

我认为您可以制作三次贝塞尔曲线，第一个点位于（0，1），第四个点（最后）位于（1，0）。可以将两个中间点随机放置在此1×1矩形内（x = rand，y = rand）。我无法通过分析来验证这一点，但是仅仅通过玩一个applet（是的，继续笑），似乎Bezier曲线将永远不会因这种限制而减小。

这将是您的基本函数b（p1，p2），它提供了从点p1到点p2的非递减路径。

现在您可以生成ab（p（1）=（0，1），p（n）=（1，0））并沿该曲线选取多个p（i）使得1

本质上，您将生成一个“通用”路径，然后将其分解为多个段并重新生成每个段。

由于您需要一个数学函数：假设上述过程打包为一个函数y = f（t，s），该函数为种子s的函数提供了t处的距离。你会需要：

• 4个随机数，用于放置主Bezier样条曲线的2个中点（从（0，1）到（1，0））
• 如果您有n个段，则n-1个数字代表每个段的边界（第一个段始终从（0，1）开始，即t = 0，最后一个段从（1,0）开始，即t = 1）
• 如果要随机化段数，则为1个数字
• 还有4个数字，用于放置t线段样条的中点

因此，每个种子必须提供以下之一：

• 0到1之间的7 + n个实数（如果要控制段数）
• 7个实数和一个大于1的整数（对于随机数的段）

我想您可以通过简单地提供一个数字数组作为种子s来完成上述任一操作。或者，您可以执行一些操作，例如提供一个数字s作为种子，然后使用rand（s），rand（s + 1），rand（s + 2）等调用内置的随机数生成器（或初始化为s，然后继续调用rand.NextNumber）。

请注意，即使整个函数f（t，s）由许多段组成，您也只需要为每个t评估一个段。您将需要使用此方法重复计算线段的边界，因为您必须对它们进行排序以确保没有两个线段重叠。您可能可以优化并摆脱这些额外的工作，只为每个调用找到一个分段的端点，但是对我而言这现在并不明显。

同样，贝塞尔曲线不是必需的，任何适当的样条曲线都可以。

我创建了一个示例Matlab实现。

Bezier函数（矢量化）：

function p = bezier(t, points)
% p = bezier(t, points) takes 4 2-dimensional points defined by 2-by-4 matrix
% points and gives the value of the Bezier curve between these points at t.
% 
% t can be a number or 1-by-n vector. p will be an n-by-2 matrix.
    coeffs = [
        (1-t').^3, ...
        3*(1-t').^2.*t', ...
        3*(1-t').*t'.^2, ...
        t'.^3
    ];

    p = coeffs * points;
end

上面描述的复合Bezier函数（故意不进行矢量化处理，以使每个调用都需要进行多少评估）：

function p = bezier_compound(t, ends, s)
% p = bezier(t, points) takes 2 2-dimensional endpoints defined by a 2-by-2
% matrix ends and gives the value of a "compound" Bezier curve between
% these points at t.
% 
% t can be a number or 1-by-n vector. s must be a 1-by-7+m vector of random
% numbers from 0 to 1. p will be an n-by-2 matrix. 
    %% Generate a list of segment boundaries
    seg_bounds = [0, sort(s(9:end)), 1];

    %% Find which segment t falls on
    seg = find(seg_bounds(1:end-1)<=t, 1, 'last');

    %% Find the points that segment boundaries evaluate to
    points(1, :) = ends(1, :);
    points(2, :) = [s(1), s(2)];
    points(3, :) = [s(3), s(4)];
    points(4, :) = ends(2, :);

    p1 = bezier(seg_bounds(seg), points);
    p4 = bezier(seg_bounds(seg+1), points);

    %% Random middle points
    p2 = [s(5), s(6)] .* (p4-p1) + p1;
    p3 = [s(7), s(8)] .* (p4-p1) + p1;

    %% Gather together these points
    p_seg = [p1; p2; p3; p4];

    %% Find what part of this segment t falls on
    t_seg = (t-seg_bounds(seg))/(seg_bounds(seg+1)-seg_bounds(seg));

    %% Evaluate
    p = bezier(t_seg, p_seg);    
end

绘制随机种子函数的脚本（请注意，这是唯一一个调用随机函数的地方，所有其他代码的随机变量都是从该随机数组传播的）：

clear
clc

% How many samples of the function to plot (higher = higher resolution)
points = 1000;

ends = [
    0, 0;
    1, 1;
    ];

% a row vector of 12 random points
r = rand(1, 12);

p = zeros(points, 2);

for i=0:points-1
    t = i/points;
    p(i+1, :) = bezier_compound(t, ends, r);
end

% We take a 1-p to invert along y-axis here because it was easier to
% implement a function for slowly moving away from a point towards another.
scatter(p(:, 1), 1-p(:, 2), '.');
xlabel('Time');
ylabel('Distance to target');

这是一个示例输出：

它似乎符合您的大多数标准。然而：

• 有“角”。通过更适当地使用贝塞尔曲线可以做到这一点。
• 它“显然”看起来像样条曲线，尽管除非您知道种子，否则您无法真正猜测它在不平凡的一段时间后会做什么。
• 它很少会向拐角偏移太多（可以通过调节种子生成器的分布来解决）。
• 给定这些约束，三次贝塞尔函数不能到达拐角附近的区域。

我猜想，您可以混合几个以f（0）= 0开始的单调函数，如f（x）= x或2x，或x ^ 2等。事实上，由于您的域限制为0 => 1，因此您还可以混合适合该域内账单的触发函数，例如cos（90 * x + 270）。要将您的方法标准化为以1结尾，您可以简单地将这些从f（0）= 0开始的单调方法的加权和除以f（1）。这样的事情也应该很容易反转（我从无状态实函数与编程函数的角度收集了您想要的东西）。

希望这可以帮助。

可以分析这张原始图片 您可以得到一个函数，该函数可以通过使用统一的rand函数即时执行动画。我知道这不是确切的数学公式，但实际上没有随机函数的数学公式，即使有一个数学函数，您也需要编写很多代码才能实现。考虑到您未指定任何平滑度条件，因此速度曲线是连续的$ C ^ 0 $（但由于您不使用机器人，因此无需担心不连续的加速曲线）。

从[0,1]生成N个随机数递增序列的通常方法是生成任意范围内的N个随机数，然后将它们全部除以它们的总和，然后一次求和以得到序列。

生成序列2、2、5、8、6。
他们的总和为23，所以我们的总和为2 / 23、2 / 23、5 / 23、8 / 23和6/23。
我们的最终顺序是2 / 23、4 / 23、9 / 23、17 / 23、23 / 23

通过为X和Y生成这些值，可以将其扩展为2D。您可以增加N以获得所需的任何粒度。

在@teodron的类似答案中，您引用了大范围的效率问题。在不知道您面临的实际问题的情况下，我无法确定这种担忧是否成立。但是另一种选择是针对较小的 N 生成并简单地平滑结果。根据应用程序，这实际上可能会产生更好的结果。

N = 100，不平滑

N = 15，具有平滑

我建议此实现的灵感来自分形噪声中发现的八度音的总和，并在此到处散布一些廉价的屁股。我相信它的速度相当快，可以通过请求比存储在参数中的参数更少的八度来进行调整，而精度损失约为1/2^octave。

您可以将其视为仅需要O（log（pieces））时间的分段实现。参数数组既用于分治制枢轴位置，也用于到达枢轴时的行进距离。

template<int N> struct Trajectory
{
    Trajectory(int seed = 0)
    {
        /* The behaviour can be tuned by changing 0.2 and 0.6 below. */
        if (seed)
            srand(seed);
        for (int i = 0; i < N; i++)
            m_params[i] = 0.2 + 0.6 * (double)(rand() % 4096) / 4096;
    }

    double Get(double t, int depth = N)
    {
        double min = 0.0, max = 1.0;
        for (int i = 0, dir = 0; i < N && i < depth; i++)
        {
            int j = (dir + 1 + i) % N;
            double mid = min + (max - min) * m_params[j];
            if (t < m_params[i])
            {
                dir += 1;
                t = t / m_params[i];
                max = mid;
            }
            else
            {
                dir ^= i;
                t = (t - m_params[i]) / (1.0 - m_params[i]);
                min = mid;
            }
        }
        t = (3.0 - 2.0 * t) * t * t; // Optional smoothing
        return min + (max - min) * t;
    }

    double m_params[N];
};

通过预先计算浮点除法，可以更快地进行存储，但需要存储三倍的信息。

这是一个简单的示例：

该示例是使用以下代码获得的：

for (int run = 0; run < 5; run++)
{
    /* Create a new shuffled trajectory */
    Trajectory<12> traj;

    /* Print dots */
    for (double t = 0; t <= 1.0; t += 0.0001)
        printf("%g %g\n", t, traj.Get(t));
}

大声思考，承认微积分不是我的强项……这也许不可能吗？为了避免出现任何明显的模式，x上任何变化的噪声函数的平均值必须接近零，并且为了确保单调性，x上该变化的噪声幅度必须小于x的变化，因为任何较大的幅度都可能导致x'处的值相对于x较低。但这意味着当您将dx减小到0时，该函数还必须将dA（其中A是幅度）减小到零，这意味着您不会从任何兼容的噪声函数中受益。

我可以想象有可能制定出一个函数，该函数可以在x接近1时逐渐降低噪声的贡献，但是会给您一个曲线函数，当x接近1时它会减速，这不是我想的。