मैं एक ऐसा फ़ंक्शन बनाने की कोशिश कर रहा हूं जो एक फ़ंक्शन f (x) को स्वयं N बार लिखता है, ऐसा कुछ:

function CompositionN(f,N)
             for i in 1:N
                f(x) = f(f(x))
             end
return f(x)

मुझे चाहिए कि फ़ंक्शन कंपोज़िशनएन एक और फ़ंक्शन देता है, मान नहीं।

5
Evelyn Alvarez 27 अक्टूबर 2020, 20:23

3 जवाब

सबसे बढ़िया उत्तर

ntuple और स्प्लैटिंग के साथ समाधान एक निश्चित संख्या में रचनाओं तक बहुत अच्छी तरह से काम करता है, जैसे कि १०, और फिर एक प्रदर्शन चट्टान से गिर जाता है।

reduce का उपयोग करने वाला एक वैकल्पिक समाधान, बड़ी संख्या में रचनाओं के लिए तेज़ है, n, लेकिन छोटी संख्याओं के लिए तुलनात्मक रूप से धीमा है:

compose_(f, n) = reduce(∘, ntuple(_ -> f, n))

मुझे लगता है कि निम्नलिखित समाधान बड़े और छोटे n दोनों के लिए इष्टतम है:

function compose(f, n)
    function (x)  # <- this is syntax for an anonymous function
        val = f(x)
        for _ in 2:n
            val = f(val)
        end
        return val
    end
end

BTW: यह कंपोज्ड फंक्शन का निर्माण है जो यहां सुझाए गए दृष्टिकोण में तेज है। परिणामी कार्यों के रनटाइम समान प्रतीत होते हैं।

2
DNF 28 अक्टूबर 2020, 01:31

आप का लाभ उठा सकते हैं ∘ फ़ंक्शन, जो आपको कई फ़ंक्शन लिखने की अनुमति देता है:

julia> composition(f, n) = ∘(ntuple(_ -> f, n)...)
composition (generic function with 1 method)

julia> composition(sin, 3)(3.14)
0.001592651569876818

julia> sin(sin(sin(3.14)))
0.001592651569876818
4
giordano 27 अक्टूबर 2020, 20:32

यहाँ एक पुनरावर्ती दृष्टिकोण है:

julia> compose(f, n) = n <= 1 ? f : f ∘ compose(f, n-1)
compose (generic function with 1 method)

julia> compose(x -> 2x, 3)(1)
8

यदि हम एक छोटी प्रकार की पायरेसी करने के इच्छुक हैं, तो हम n-वें क्रम स्व-संरचना का प्रतिनिधित्व करने के लिए फ़ंक्शन पर पावर ऑपरेटर ^ का उपयोग कर सकते हैं:

julia> Base.:^(f::Union{Type,Function}, n::Integer) = n <= 1 ? f : f ∘ f^(n-1)

julia> f(x) = 2x
f (generic function with 1 method)

julia> (f^3)(1)
8
1
Cameron Bieganek 28 अक्टूबर 2020, 17:51