क्या (गैर-घटता शोर समारोह) का एक (परिवार) है?

Question

मैं समय-समय पर बिंदु A से बिंदु B पर जाने वाली किसी वस्तु को चेतन करने के लिए एक कार्य करना चाहता हूं, जैसे कि यह किसी निश्चित समय पर B तक पहुंचता है, लेकिन किसी भी समय इसकी स्थिति बेतरतीब ढंग से निरंतर रूप से विकृत होती है, लेकिन कभी पीछे नहीं जाती है। ऑब्जेक्ट सीधी रेखाओं के साथ चलते हैं, इसलिए मुझे केवल एक आयाम की आवश्यकता है।

गणितीय रूप से, इसका मतलब है कि मैं कुछ निरंतर f (x), x 0 [0,1] की तलाश कर रहा हूं, जैसे:

• f (0) = 0
• f (1) = 1
• x <y → f (x) (f (y)
• "अधिकांश" बिंदुओं पर f (x + d) - f (x) d का कोई स्पष्ट संबंध नहीं है। (फ़ंक्शन समान रूप से नहीं बढ़ रहा है या अन्यथा पूर्वानुमेय है; मुझे लगता है कि यह भी कहना है कि व्युत्पन्न की कोई डिग्री स्थिर नहीं है।)

आदर्श रूप से, मैं वास्तव में इन कार्यों के एक परिवार के लिए कुछ रास्ता देना चाहूंगा, कुछ बीज राज्य प्रदान करूंगा। मुझे अपने वर्तमान उपयोग के लिए कम से कम 4 बिट्स सीड (16 संभावित फ़ंक्शंस) की आवश्यकता होगी, लेकिन चूंकि यह बहुत अधिक प्रदान करने के लिए स्वतंत्र नहीं है।

संचय त्रुटियों के साथ विभिन्न मुद्दों से बचने के लिए, मैं इस फ़ंक्शन को किसी भी प्रकार की आंतरिक स्थिति की आवश्यकता नहीं पसंद करूंगा । यही है, मैं चाहता हूं कि यह एक वास्तविक कार्य हो, न कि एक प्रोग्रामिंग "फ़ंक्शन"।

Comments

आपकी तीसरी और चौथी आवश्यकता के रूप में अनुमान लगाया जा सकता है f'(x)>0, इसलिए किसी भी शोर फ़ंक्शन के पूर्ण मूल्य का सामान्यीकृत एकीकरण आपकी सभी आवश्यकताओं को पूरा करेगा। दुर्भाग्य से मुझे इसकी गणना करने का कोई आसान तरीका नहीं पता है, लेकिन शायद कोई और करता है। :)

— स्किमफ्लक्स

क्या आपके कार्य के लंबवत तात्कालिक ढलान कार्य को प्रभावित करेगा?

— कावड़

जब आप कहते हैं "संचय त्रुटियों के साथ विभिन्न मुद्दों से बचने के लिए" मुझे लगा कि आप परिशुद्धता के बारे में चिंतित थे। ऐसा लगता है कि, आपकी कई टिप्पणियों के आधार पर, आप अत्यधिक मूल्यांकन के प्रदर्शन की लागत से चिंतित हैं। आपको वास्तव में यह बताना चाहिए कि प्रदर्शन और मेमोरी की बाधाएँ किसके अधीन हैं - आवश्यकता वैसे भी अकारण है क्योंकि कोई व्यक्ति राज्य के साथ ऐसे कार्यों का निर्माण कर सकता है जिनमें संचय त्रुटियां नहीं हैं (इसका क्या मतलब है, वैसे भी?)। साथ ही, आपका 4 वां अंक गलत है। एक तुच्छ उदाहरण: e ^ x का कोई व्युत्पन्न स्थिर नहीं है, इसलिए यह कहने के बराबर नहीं है।

— सुपरस्टार

Answer 1

इस पद के लिए, y = f (t) जहां t वह पैरामीटर है जिसे आप बदलते हैं (समय / प्रगति) और y लक्ष्य के लिए दूरी है। इसलिए मैं 2D प्लॉट पर उन बिंदुओं के संदर्भ में बात करूंगा जहां क्षैतिज अक्ष समय / प्रगति है और ऊर्ध्वाधर दूरी है।

मुझे लगता है कि आप पहले (0, 1) और चौथे (अंतिम) बिंदु पर (1, 0) के साथ एक क्यूबिक बेजियर वक्र बना सकते हैं। दो मध्य बिंदुओं को इस 1-बाय -1 आयत के भीतर यादृच्छिक रूप से रखा जा सकता है (x = रैंड, y = रैंड)। मैं इसे विश्लेषणात्मक रूप से सत्यापित करने में असमर्थ हूं, लेकिन सिर्फ एक एप्लेट (हाँ, आगे बढ़ो और हँसो) के साथ खेलने से ऐसा लगता है कि इस तरह की बाधा के साथ बेजियर वक्र कभी कम नहीं होगा।

यह आपका प्रारंभिक कार्य b (p1, P2) होगा जो बिंदु p1 से बिंदु P2 तक एक गैर-घटता हुआ पथ प्रदान करता है।

अब आप ab (p (1) = (0, 1), p (n) = (1, 0)) उत्पन्न कर सकते हैं और इस वक्र के साथ p (i) का एक नंबर चुनें जैसे कि 1

अनिवार्य रूप से, आप एक "सामान्य" पथ उत्पन्न कर रहे हैं, और फिर इसे खंडों में तोड़कर प्रत्येक खंड को पुन: उत्पन्न कर रहे हैं।

चूंकि आप एक गणितीय कार्य चाहते हैं: मान लीजिए कि उपरोक्त प्रक्रिया एक फ़ंक्शन y = f (t, s) में पैक की गई है, जो आपको बीज s के कार्य के लिए t पर दूरी प्रदान करती है। आपको चाहिये होगा:

• मुख्य बेज़ियर रेखा के 2 मध्य बिंदु (से (0, 1) से (1, 0) रखने के लिए 4 यादृच्छिक संख्याएँ
• यदि आपके पास n सेगमेंट (हमेशा पहला सेगमेंट (0, 1) यानी टी = 0 पर शुरू होता है और अंतिम छोर पर (1,0) यानी टी = 1 है तो प्रत्येक सेगमेंट की सीमा के लिए एन -1 नंबर
• 1 नंबर यदि आप सेगमेंट की संख्या को यादृच्छिक करना चाहते हैं
• सेगमेंट की तर्ज के मध्य बिंदुओं को रखने के लिए 4 और संख्याएँ, आपकी टी भूमि पर

इसलिए प्रत्येक बीज को निम्नलिखित में से एक की आपूर्ति करनी चाहिए:

• 0 और 1 के बीच 7 + एन वास्तविक संख्या (यदि आप सेगमेंट की संख्या को नियंत्रित करना चाहते हैं)
• 7 वास्तविक संख्या और 1 से अधिक पूर्णांक (यादृच्छिक संख्या में सेगमेंट के लिए)

मुझे लगता है कि आप इन दोनों में से किसी एक को केवल बीज s के रूप में संख्या की आपूर्ति करके पूरा कर सकते हैं। वैकल्पिक रूप से, आप बीज के रूप में एक नंबर की आपूर्ति की तरह कुछ कर सकते हैं, और फिर रैंड (ओं), रैंड (s + 1), रैंड (s + 2) और इतने पर (या साथ आरंभ) के साथ अंतर्निहित यादृच्छिक संख्या जनरेटर को कॉल कर सकते हैं s और उसके बाद rand.NextNumber) पर कॉल करते रहें।

ध्यान दें कि भले ही पूरा फ़ंक्शन f (t, s) कई खंडों से बना है, आप केवल प्रत्येक t के लिए एक खंड का मूल्यांकन कर रहे हैं। आपको इस पद्धति के साथ खंडों की सीमाओं की बार-बार गणना करने की आवश्यकता होगी , क्योंकि आपको यह सुनिश्चित करने के लिए उन्हें क्रमबद्ध करना होगा कि कोई दो खंड ओवरलैप न हों। आप संभवतः इस अतिरिक्त कार्य से अनुकूलन कर सकते हैं और छुटकारा पा सकते हैं और केवल प्रत्येक कॉल के लिए एक सेगमेंट के समापन बिंदु ढूंढ सकते हैं, लेकिन अभी मेरे लिए यह स्पष्ट नहीं है।

इसके अलावा, बेज़ियर कर्व्स आवश्यक नहीं हैं, किसी भी उपयुक्त व्यवहार करने वाली तख़्ती करेंगे।

मैंने एक नमूना मैटलैब कार्यान्वयन बनाया।

बेज़ियर फ़ंक्शन (वेक्टरकृत):

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

ऊपर वर्णित यौगिक बेज़ियर फ़ंक्शन (यह जानबूझकर स्पष्ट नहीं छोड़ा गया कि यह स्पष्ट करने के लिए कि प्रत्येक कॉल के लिए मूल्यांकन कितना आवश्यक है):

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

यहाँ एक नमूना आउटपुट है:

यह आपके अधिकांश मानदंडों को पूरा करता है। तथापि:

• "कोने" हैं। यह बेज़ियर घटता का उपयोग करके अधिक उपयुक्त रूप से उपयोग योग्य हो सकता है।
• यह "स्पष्ट रूप से" स्प्लीन की तरह दिखता है, हालांकि आप वास्तव में अनुमान नहीं लगा सकते हैं कि यह गैर-तुच्छ अवधि के बाद क्या करेगा जब तक कि आप बीज को नहीं जानते।
• यह बहुत कम ही कोने की ओर अधिक विचलन करता है (बीज जनरेटर के वितरण के साथ खेलकर तय किया जा सकता है)।
• क्यूबिक बेज़ियर फ़ंक्शन इन बाधाओं को दिए गए कोने के पास एक क्षेत्र तक नहीं पहुंच सकता है।

Answer 2

मेरा अनुमान है कि बदले हुए कोसिनों का एक गुच्छा सम्मिश्रण के बजाय (जैसे कि perlin शोर में डॉट उत्पाद आपको देते हैं), आप कई मोनोटोनिक कार्यों को मिश्रण कर सकते हैं जो f (0) = 0, जैसे f (x) = x, या 2x या या x ^ 2, आदि। चूंकि आपका डोमेन 0 => 1 तक सीमित है, इसलिए आप ट्रिम फ़ंक्शंस में भी मिश्रण कर सकते हैं जो उस डोमेन जैसे बिल (90 * x + 270) के भीतर बिल को फिट करते हैं। 1 पर समाप्त होने के लिए अपने तरीकों को सामान्य करने के लिए, आप इन मोनोटोनिक तरीकों की भारित राशि को f (0) = 0 से f (1) से विभाजित कर सकते हैं। इस तरह से कुछ आसान होना चाहिए, साथ ही इनवर्ट करना भी आसान है (जो मैं इकट्ठा करता हूं, आप स्टेटलेस रियल फंक्शन्स बनाम प्रोग्रामिंग फंक्शन्स के बारे में चाहते हैं)।

उम्मीद है की यह मदद करेगा।

Answer 3

कोई भी इस कच्चे चित्र का विश्लेषण कर सकता है। आप एक फ़ंक्शन के साथ समाप्त हो सकते हैं जो मक्खी पर आपके एनीमेशन का प्रदर्शन करता है, एक समान रैंड फ़ंक्शन का उपयोग करके। मुझे पता है कि यह सटीक गणितीय सूत्र नहीं है, लेकिन वास्तव में यादृच्छिक फ़ंक्शन के लिए कोई गणितीय सूत्र नहीं है, और यहां तक ​​कि अगर एक थे, तो आप इसे प्राप्त करने के लिए बहुत कोडिंग करेंगे। यह ध्यान में रखते हुए कि आपने कोई चिकनाई की स्थिति निर्दिष्ट नहीं की है, गति प्रोफ़ाइल $ C ^ 0 $ निरंतर है (लेकिन चूंकि आप रोबोट के साथ काम नहीं कर रहे हैं, इसलिए आपको बंद त्वरण प्रोफाइल के बारे में चिंता करने की कोई आवश्यकता नहीं है)।

Comments

"यादृच्छिक समारोह के लिए वास्तव में कोई गणितीय सूत्र नहीं है" मुझे एक शोर समारोह चाहिए, एक यादृच्छिक फ़ंक्शन नहीं। शोर कार्यों को अच्छी तरह से मौजूद होने के लिए प्रलेखित किया गया है। इस तरह की टुकड़ों की परिभाषाएँ भी अक्षमता पैदा करती हैं (मूल्यांकन हो जाता है ओ (टुकड़े) जो एक समस्या बन जाता है जब आपके पास लंबे समय तक तराजू होता है), अशुद्ध कार्य (ओ में मूल्यांकन (1) लेकिन पिछले स्थिति को बनाए रखने की आवश्यकता है), या उससे अधिक विवश संभावित कार्य (जैसे सभी विभक्ति बिंदु निश्चित अंतराल पर हैं)।

हम्म, क्षमा करें, मैंने सोचा था कि शोर फ़ंक्शन भी एक यादृच्छिक संख्या जनरेटर प्रक्रिया का उपयोग करते हैं और यह भी एक आकृति प्राप्त करने के लिए गाइड / कुंजी बिंदुओं के असतत सेट पर निर्भर होते हैं (मैंने देखा कि पेर्लिन शोर का उल्लेख किया गया था .. कि एक छद्म यादृच्छिक के माध्यम से काम करता है संख्या जनरेटर जो कि एकीकृत करने के लिए काफी कठिन हैं, इसलिए कोई विश्लेषणात्मक समाधान नहीं है)। क्या कोई शोर समारोह को विश्लेषणात्मक रूप से एकीकृत कर सकता है? मुझे आश्चर्य हो रहा है कि क्या इनमें से कोई एक उम्मीदवार लिंक

— टेओड्रन

एक उदाहरण के रूप में, पेर्लिन शोर 255 8 बिट संख्या का बीज राज्य लेता है, लेकिन इससे तीन आयामों में अनंत दूरी में यादृच्छिक शोर उत्पन्न होता है; उन्हें "गाइड पॉइंट" के रूप में वर्णित करना वास्तव में सटीक नहीं है, गणितीय रूप से वे अन्य 256 मापदंडों की तरह हैं जिन्हें आप प्रदान नहीं करना चाहते हैं। जैसा कि आप कहते हैं कि यह अनिवार्य रूप से पूर्ण नहीं है, लेकिन यह एक शुद्ध कार्य है। आपके द्वारा जोड़ा गया पृष्ठ पेरलिन शोर का एक बुरा स्पष्टीकरण है (यह वास्तव में पेरलिन शोर नहीं है जो वह बताते हैं)। जैसे कि क्या यह किसी प्रकार के शोर समारोह के लिए संभव है ... ठीक है, यह सवाल है, है ना?

Answer 4

[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 को बढ़ा सकते हैं।

---

@ टेओड्रॉन के समान उत्तर में, आपने बड़े समय-पैमाने के साथ दक्षता चिंताओं का हवाला दिया। आपके सामने आने वाली वास्तविक समस्या को जाने बिना, मैं यह नहीं बता सकता कि क्या यह चिंता वैध है; लेकिन एक और विकल्प छोटे एन के लिए उत्पन्न होगा , और बस परिणाम को सुचारू करेगा। आवेदन के आधार पर, यह वास्तव में बेहतर परिणाम दे सकता है ।

एन = 100, कोई चौरसाई नहीं

एन = 15, चौरसाई के साथ

Comments

जो कुछ भी आप चौरसाई के लिए कर रहे हैं, ऐसा लगता है कि परिणाम एक फ़ंक्शन (x = 0.95 के आसपास) भी नहीं बना है; मुझे यकीन नहीं है कि अगर यह आपके रेखांकन कार्यक्रम की एक कलाकृति या एक गलती है। अखंडता का भी 0.7 के आसपास उल्लंघन होता है। वैसे भी, मैं "सामान्य तरीके" से परिचित हूं - मैं यह सवाल पूछ रहा हूं क्योंकि मुझे संदेह है कि सामान्य तरीका भद्दा है। प्री-पेरलिन-शोर, आखिरकार, किसी को भी मूल्य शोर के विशाल एलयूटी के साथ कोई समस्या नहीं थी, यह सिर्फ "सामान्य तरीका" था। आज, हमारे पास एक ऐसा तरीका है जो काफी अधिक लचीला और कुशल है।

मैं ब्लूराजा से सहमत हूं: एकरसता का उल्लंघन किए बिना स्मूथिंग के जाने-माने, आसानी से लागू होने वाले तरीके हैं, उदाहरण की परवाह किए बिना। उदाहरण के लिए, चलती औसत या ड्राइंग विभाजन। हालाँकि, @JoeWreschnig चिंता अप्रासंगिक नहीं है। गेम के नियम और मैकेनिक वस्तुओं पर निर्भर हो सकते हैं जो कभी भी कार्य करने के लिए पीछे नहीं हटते हैं - यह शायद ही कभी एक अच्छा विचार है कि पूछने वाले को वास्तव में वह नहीं चाहिए जो वह कहता है कि उसे क्या चाहिए।

— 20

@BlueRaja: इस तरह के टुकड़े-टुकड़े के तरीकों के बारे में मेरी बुनियादी शिकायतें तेदुंए की मेरी प्रतिक्रिया में वर्णित हैं। यह "सबसे कठोर और गणितीय-सटीक परिणाम" खोजने के बारे में नहीं है - यह हमारे लिए पहले से अज्ञात एक गणितीय उपकरण के साथ नई संभावनाओं को खोलने के बारे में है। फिर से, विशाल मूल्य शोर LUTs और Perlin शोर के बीच समानता पर विचार करें। साइट पर हर प्रश्न को ऑफ-द-कफ की आवश्यकता नहीं होती है "अच्छा पर्याप्त" उत्तर किसी भी आधे रास्ते में बुद्धिमान सीएस अंडरग्रेड व्याख्यान के बीच बाहर धमाका कर सकता है - कभी-कभी, कुछ मूल और पेशेवर करने के लिए शूट करें, ठीक है?

या हम केवल परिवर्तन मैट्रीक के बारे में 90% प्राथमिक भ्रम में इस साइट की दीवार को जारी रखने के लिए जारी रख सकते हैं, 10% "खेल को रोकने में मदद करें!" यह एक बढ़िया क्यू एंड ए साइट बना देगा जो हर पेशेवर को पसंद आएगा।

@ जो: यह, erm, के लिए अनकहा है। आपने अपने मानदंडों को पूरा करने के लिए एक उपाय पूछा, मैंने आपको एक दिया। सिर्फ इसलिए कि यह सरल है यह बुरा नहीं बनाता है।

— ब्लूराजा - डैनी पफ्लुगुएट

Answer 5

मुझे लगता है कि यह कार्यान्वयन फ्रैक्टल शोर में पाए गए सप्तक के योग से प्रेरित है, यहां और वहां सस्ते गधों के फेरबदल के साथ। मेरा मानना ​​है कि यह काफी तेजी से है और इसके बारे में सटीक की हानि के साथ मापदंडों में संग्रहीत की तुलना में कम ऑक्टेव्स पूछकर ट्यून किया जा सकता है 1/2^octave।

आप इसे एक टुकड़े-टुकड़े कार्यान्वयन के रूप में देख सकते हैं जिसमें केवल ओ (लॉग (टुकड़े)) समय की आवश्यकता होती है । पैरामीटर ऐरे का उपयोग डिवाइड-एंड-कॉनवेअर पिवट पोजिशन के लिए किया जाता है, और पिवट तक पहुंचने पर यात्रा की गई दूरी के लिए।

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

Answer 6

जोर से सोचना, और पथरी को स्वीकार करना मेरा मजबूत बिंदु नहीं है ... क्या यह संभव नहीं है? किसी भी स्पष्ट पैटर्न से बचने के लिए, x में किसी भी बदलाव पर शोर का औसत शून्य के करीब होना चाहिए, और एकरसता की गारंटी देने के लिए कि x में परिवर्तन पर शोर का आयाम x में परिवर्तन से छोटा होना चाहिए, क्योंकि कोई भी बड़ा आयाम हो सकता है। x के सापेक्ष 'x' पर कम मूल्य का परिणाम। लेकिन इसका मतलब यह होगा कि जैसे आप dx को 0 की ओर कम करते हैं, ऐसे फ़ंक्शन को dA (जहाँ A आयाम है) को भी शून्य की ओर कम करना चाहिए, जिसका अर्थ है कि आपको किसी भी अनुरूप शोर फ़ंक्शन से कोई योगदान नहीं मिलता है।

मैं कल्पना कर सकता हूं कि एक फ़ंक्शन तैयार करना संभव है जो धीरे-धीरे शोर योगदान को कम कर देता है क्योंकि एक्स 1 से संपर्क करता है, लेकिन इससे आपको एक घुमावदार फ़ंक्शन मिलेगा जो एक्स दृष्टिकोण 1 के रूप में घटता है, जो कि मुझे नहीं लगता कि आप चाहते हैं।

Comments

मैं इस तरह के कार्यों के लाखों ग्राफ खींच सकता हूं, और जैसा कि स्किमफ्लक्स कहता है कि शोर फ़ंक्शन का एकीकरण यदि आप इसे सामान्य करते हैं तो यह व्यावहारिक रूप से समकक्ष फ़ंक्शन देता है। इसलिए फ़ंक्शन मौजूद हैं , यह केवल एक मामला है कि क्या उन्हें संभव कोडित किया जा सकता है । इसलिए यहां गणित के बजाय पूछ रहे हैं।

उदाहरण के लिए, x फंक्शन 1 के g(x) = 1 - f(1 - x)रूप में

ज़रूर, फ़ंक्शंस मौजूद हैं - आप एक को आकर्षित कर सकते हैं जैसे टेओड्रन ने किया - लेकिन क्या वे 'शोर' कार्य हैं? शोर एक बेसलाइन के सापेक्ष अंतर्निहित आयाम के साथ छद्म यादृच्छिक इनपुट के आधार पर एक सतत कार्य का तात्पर्य करता है। और अगर वह आयाम बहुत अधिक है तो आप आउटपुट मोनोटोनिक रखने के लिए चरणों के बीच के अंतर को कम नहीं कर सकते। लेकिन यह मेरे लिए होता है कि शोर का घनत्व और प्रक्षेप चरण आपके विनिर्देशों को पूरा करने के लिए तैयार किया जा सकता है, जिसके बारे में मैं थोड़ा और सोचने जा रहा हूं।

— काइलोटन

शोर का मतलब सिर्फ यह है कि यह "अप्रत्याशित" है, यह पीढ़ी के तरीकों (या यहां तक ​​कि तकनीकी रूप से, निरंतरता के बारे में कुछ नहीं कहता है, हालांकि एनीमेशन के लिए आप लगभग हमेशा सुसंगत शोर चाहते हैं)। यह सही है कि फिक्स्ड एंडपॉइंट्स इस फ़ंक्शन के संभावित आयाम को कुछ हद तक बाधित करते हैं, लेकिन पूरी तरह से नहीं। अन्य शोर कार्यों में समान गुण होते हैं, उदाहरण के लिए किसी भी पूर्णांक x के लिए Perlin (x) = 0। मोनोटोनिकिटी उससे अधिक मजबूत गारंटी है, लेकिन मुझे नहीं लगता कि यह इतना मजबूत है कि यह असंभव है।

@JoeWreschnig मुझे यकीन है कि आप इस बात से अवगत हैं कि पेरलिन शोर समारोह आपके कई मानदंडों का उल्लंघन करता है। सबसे पहले यह ग्रिड नोड्स पर 0 से होकर गुजरता है इसलिए f (x + d) -f (x) कुछ निश्चित (नियमित रूप से स्थान दिया गया) x के लिए एक स्थिर गुणक है। इसके अतिरिक्त, उस चालाक कैशिंग चाल के कारण, यह बड़े ग्रिड के लिए दोहराएगा। क्लासिक शोर के लिए, मुझे लगता है कि संदर्भ कार्यान्वयन ग्रिड टाइल (x, y) टाइल (x + 256, y / 256) के समान होना चाहिए। आपको यह बताना चाहिए कि यह स्वीकार्य है, और किस हद तक।

— सुपरस्टार