Có (họ) chức năng tiếng ồn không giảm đơn điệu không?

Tôi muốn một chức năng làm sống động một vật thể di chuyển từ điểm A đến điểm B theo thời gian, sao cho nó đến B vào một thời điểm cố định, nhưng vị trí của nó bất cứ lúc nào cũng bị xáo trộn một cách ngẫu nhiên, nhưng không bao giờ bị lùi lại. Các đối tượng di chuyển dọc theo các đường thẳng, vì vậy tôi chỉ cần một chiều.

Về mặt toán học, điều đó có nghĩa là tôi đang tìm kiếm một số f (x), x ∈ [0,1] liên tục, sao cho:

• f (0) = 0
• f (1) = 1
• x <y → f (x) f (y)
• Tại "hầu hết" các điểm f (x + d) - f (x) không có mối quan hệ rõ ràng với d. (Hàm này không tăng đồng đều hoặc có thể dự đoán được; tôi nghĩ điều đó cũng tương đương với việc nói không có mức độ phái sinh là một hằng số.)

Lý tưởng nhất, tôi thực sự muốn có một số cách để có một gia đình các chức năng này, cung cấp một số trạng thái hạt giống. Tôi cần ít nhất 4 bit hạt giống (16 chức năng có thể), cho mục đích sử dụng hiện tại của tôi, nhưng vì điều đó không có nhiều khả năng để cung cấp nhiều hơn.

Để tránh các vấn đề khác nhau với lỗi tích lũy, tôi thích chức năng không yêu cầu bất kỳ loại trạng thái nội bộ nào. Đó là, tôi muốn nó là một chức năng thực sự, không phải là một "chức năng" lập trình.

Đối với bài đăng này, y = f (t) trong đó t là tham số bạn thay đổi (thời gian / tiến độ) và y là khoảng cách đến mục tiêu. Vì vậy, tôi sẽ nói về các điểm trên các ô 2D trong đó trục ngang là thời gian / tiến độ và chiều dọc là khoảng cách.

Tôi nghĩ bạn có thể tạo một đường cong Bezier hình khối với điểm đầu tiên tại (0, 1) và điểm thứ tư (cuối cùng) tại (1, 0). Hai điểm giữa có thể được đặt ngẫu nhiên (x = rand, y = rand) trong hình chữ nhật 1-1 này. Tôi không thể xác minh điều này một cách phân tích, nhưng chỉ từ việc chơi xung quanh với một applet (vâng, hãy tiếp tục và cười) có vẻ như đường cong Bezier sẽ không bao giờ giảm với một ràng buộc như vậy.

Đây sẽ là hàm cơ bản b (p1, p2) của bạn cung cấp đường dẫn không giảm từ điểm p1 đến điểm p2.

Bây giờ bạn có thể tạo ab (p (1) = (0, 1), p (n) = (1, 0)) và chọn một số p (i) dọc theo đường cong này sao cho 1

Về cơ bản, bạn đang tạo một đường dẫn "chung", sau đó chia nó thành các phân đoạn và tạo lại mỗi phân đoạn.

Vì bạn muốn có một hàm toán học: Giả sử quy trình trên được đóng gói thành một hàm y = f (t, s) cung cấp cho bạn khoảng cách tại t cho hàm của hạt giống s. Bạn sẽ cần:

• 4 số ngẫu nhiên để đặt 2 điểm giữa của spline Bezier chính (từ (0, 1) đến (1, 0))
• n-1 số cho giới hạn của mỗi phân đoạn nếu bạn có n phân đoạn (phân đoạn đầu tiên luôn bắt đầu tại (0, 1) tức là t = 0 và kết thúc cuối cùng tại (1,0) tức là t = 1)
• 1 số nếu bạn muốn chọn ngẫu nhiên số lượng phân khúc
• Thêm 4 số để đặt các điểm giữa của spline của đoạn mà t của bạn hạ cánh tại

Vì vậy, mỗi hạt giống phải cung cấp một trong những điều sau đây:

• 7 + n số thực từ 0 đến 1 (nếu bạn muốn kiểm soát số lượng phân khúc)
• 7 số thực và một số nguyên lớn hơn 1 (cho một số phân đoạn ngẫu nhiên)

Tôi tưởng tượng bạn có thể thực hiện một trong hai điều này bằng cách đơn giản là cung cấp một mảng các số làm hạt giống. Ngoài ra, bạn có thể làm một cái gì đó như cung cấp một số s làm hạt giống, sau đó gọi trình tạo số ngẫu nhiên tích hợp với rand (s), rand (s + 1), rand (s + 2), v.v. s và sau đó tiếp tục gọi rand.NextNumber).

Lưu ý rằng mặc dù toàn bộ hàm f (t, s) được tạo thành từ nhiều phân đoạn, bạn chỉ đánh giá một phân đoạn cho mỗi t. Bạn sẽ cần phải liên tục tính toán ranh giới của các phân đoạn bằng phương pháp này, bởi vì bạn sẽ phải sắp xếp chúng để đảm bảo không có hai phân đoạn trùng nhau. Bạn có thể có thể tối ưu hóa và loại bỏ công việc bổ sung này và chỉ tìm thấy các điểm cuối của một phân đoạn cho mỗi cuộc gọi, nhưng điều này đối với tôi không rõ ràng ngay bây giờ.

Ngoài ra, đường cong Bezier là không cần thiết, bất kỳ spline hành xử phù hợp sẽ làm.

Tôi đã tạo một triển khai Matlab mẫu.

Hàm Bezier (vector hóa):

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

Hàm Bezier ghép được mô tả ở trên (cố tình bỏ trống không được ghi chú để làm rõ mức độ cần thiết cho mỗi cuộc gọi):

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

Kịch bản vẽ đồ thị cho hàm ngẫu nhiên (lưu ý rằng đây là nơi duy nhất gọi hàm ngẫu nhiên, các biến ngẫu nhiên cho tất cả các mã khác được truyền từ một mảng ngẫu nhiên này):

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');

Đây là một đầu ra mẫu:

Nó dường như đáp ứng hầu hết các tiêu chí của bạn. Tuy nhiên:

• Có "góc". Điều này có thể được chấp nhận bằng cách sử dụng các đường cong Bezier phù hợp hơn.
• Nó "rõ ràng" trông giống như splines, mặc dù bạn thực sự không thể đoán nó sẽ làm gì sau một khoảng thời gian không tầm thường trừ khi bạn biết hạt giống.
• Nó rất hiếm khi lệch quá nhiều về góc (có thể được sửa bằng cách chơi với phân phối của trình tạo hạt giống).
• Hàm Bezier hình khối không thể đạt đến một khu vực gần góc với các ràng buộc này.

Tôi đoán rằng thay vì pha trộn một loạt các cosin biến đổi (như các sản phẩm chấm trong tiếng ồn perlin mang lại cho bạn), bạn có thể pha trộn một số hàm đơn điệu bắt đầu ở f (0) = 0, như f (x) = x, hoặc 2x, hoặc x ^ 2, v.v. Trên thực tế vì tên miền của bạn bị giới hạn ở 0 => 1, bạn cũng có thể pha trộn các hàm lượng giác phù hợp với hóa đơn trong miền đó như cos (90 * x + 270). Để bình thường hóa các phương thức của bạn kết thúc ở 1, bạn chỉ cần chia tổng trọng số của các phương thức đơn điệu này bắt đầu từ f (0) = 0 cho f (1). Một cái gì đó như thế này cũng khá dễ dàng để đảo ngược (mà tôi tập hợp bạn muốn từ bit về các hàm thực không trạng thái so với các hàm lập trình).

Hi vọng điêu nay co ich.

Người ta có thể phân tích bức tranh thô này Bạn có thể kết thúc với một chức năng thực hiện hoạt hình của mình một cách nhanh chóng, bằng cách sử dụng chức năng rand thống nhất. Tôi biết đây không phải là công thức toán học chính xác, nhưng thực tế không có công thức toán học nào cho một hàm ngẫu nhiên và thậm chí nếu có một công thức, bạn sẽ mã hóa rất nhiều để đạt được điều này. Xem xét bạn không chỉ định bất kỳ điều kiện độ mịn nào, cấu hình tốc độ là $ C ^ 0 $ liên tục (nhưng vì bạn không làm việc với robot, nên không cần phải lo lắng về cấu hình tăng tốc không liên tục).

Cách thông thường để tạo ra một chuỗi số ngẫu nhiên N tăng dần từ [0,1] là tạo N số ngẫu nhiên trong bất kỳ phạm vi nào, sau đó chia tất cả chúng cho tổng của chúng, sau đó tổng hợp chúng một lần để có được sự nối tiếp.

Tạo chuỗi 2, 2, 5, 8, 6.
Tổng của chúng là 23, vì vậy các số của chúng tôi để tính tổng là 2/23, 2/23, 5/23, 8/23 và 6/23.
Trình tự cuối cùng của chúng tôi là 2/23, 4/23, 9/23, 17/23, 23/23

Điều này có thể được mở rộng thành 2D bằng cách tạo các giá trị này cho cả X và Y. Bạn có thể tăng N để có bất kỳ mức độ chi tiết nào bạn muốn.

Trong câu trả lời tương tự của @ teodron, bạn đã trích dẫn mối quan tâm về hiệu quả với quy mô thời gian lớn. Không biết vấn đề thực sự bạn gặp phải, tôi không thể biết liệu mối quan tâm đó có hợp lệ hay không; nhưng một tùy chọn khác sẽ là tạo ra N nhỏ và đơn giản là làm mịn kết quả. Tùy thuộc vào ứng dụng, điều này thực sự có thể cho kết quả tốt hơn .

N = 100, không làm mịn

N = 15, với làm mịn

Tôi đề nghị thực hiện này lấy cảm hứng từ việc tổng hợp các quãng tám được tìm thấy trong tiếng ồn fractal, với một chút mông rẻ tiền xáo trộn ở đây và đó. Tôi tin rằng nó khá nhanh và có thể được điều chỉnh bằng cách yêu cầu số quãng tám ít hơn so với được lưu trữ trong các tham số với độ chính xác khoảng 1/2^octave.

Bạn có thể xem nó như là một triển khai từng phần chỉ yêu cầu thời gian O (log (miếng)) . Mảng tham số được sử dụng cho cả vị trí trục chia và chinh phục và cho quãng đường di chuyển khi đạt đến trục.

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];
};

Nó có thể được thực hiện nhanh hơn bằng cách tính toán trước các phân chia dấu phẩy động, với chi phí lưu trữ gấp ba lần thông tin.

Đây là một ví dụ nhanh:

Ví dụ thu được với đoạn mã sau:

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));
}

Suy nghĩ thành tiếng, và thừa nhận tính toán không phải là điểm mạnh của tôi ... điều này có lẽ là không thể? Để tránh bất kỳ mô hình rõ ràng nào, trung bình của hàm nhiễu trên bất kỳ thay đổi nào trong x phải gần bằng 0 và để đảm bảo tính đơn điệu, biên độ của nhiễu đối với thay đổi trong x phải nhỏ hơn thay đổi trong x, vì bất kỳ biên độ lớn hơn nào cũng có thể dẫn đến giá trị thấp hơn tại x 'so với x. Nhưng điều đó có nghĩa là khi bạn giảm dx về 0, thì hàm đó cũng phải giảm dA (trong đó A là biên độ) về 0, nghĩa là bạn không nhận được sự đóng góp nào từ bất kỳ chức năng nhiễu tuân thủ nào.

Tôi có thể tưởng tượng rằng có thể hình thành một hàm làm giảm dần sự đóng góp tiếng ồn khi x tiến đến 1, nhưng điều đó sẽ cung cấp cho bạn một hàm cong giảm tốc khi x tiếp cận 1, đó không phải là điều tôi nghĩ bạn muốn.