Julia: Funktionen und Strukturen als Funktionen

Trotz der Tatsache, dass dem Konzept von Julia die „klassische“ objektorientierte Programmierung mit Klassen und Methoden fehlt, bietet die Sprache Abstraktionswerkzeuge, eine Schlüsselrolle, die das Typensystem und die Elemente der funktionalen Programmierung spielen. Betrachten wir den zweiten Punkt genauer.

Das Funktionskonzept in Julia ist wahrscheinlich den Sprachen aus der Lisp-Familie (genauer gesagt den Lisp-1-Zweigen) am ähnlichsten, und Funktionen können auf drei Ebenen betrachtet werden: als Unterprogramme, als Abstraktionen zu einer bestimmten Abfolge von Aktionen und als Daten, die diese Abstraktion darstellen .

Stufe 1. Funktioniert als Routine

Die Zuweisung von Unterprogrammen und die Zuweisung eigener Namen erfolgt seit prähistorischen Zeiten, als Fortran als Hochsprache galt und C noch nicht da war.

In diesem Sinne sind Julia-Produkte Standard. "Feature" kann als die Tatsache bezeichnet werden, dass es syntaktisch keine Unterteilung in Prozeduren und Funktionen gibt. Unabhängig davon, ob das Unterprogramm aufgerufen wird, um einen Wert abzurufen oder nur eine Aktion für die Daten auszuführen, wird es als Funktion bezeichnet.

Die Definition einer Funktion beginnt mit der Schlüsselwortfunktion, gefolgt von einer Liste von Argumenten, einer Folge von Befehlen in Klammern, und das Wortede beendet die Definition:

 """ sum_all(collection) Sum all elements of a collection and return the result """ function sum_all(collection) sum = 0 for item in collection sum += collection end sum end 

Die Syntax unterscheidet sich durch das von Lisp geerbte Verhalten: Für eine "normale" Rückgabe eines Wertes aus einer Funktion ist die Wortrückgabe nicht erforderlich: Der Wert des letzten Ausdrucks, der vor der Rückgabe des end berechnet wurde. Im obigen Beispiel wird der Wert der variablen sum zurückgegeben. Somit kann return als Marker für ein bestimmtes Funktionsverhalten verwendet werden:

 function safe_division(number, divisor) if divisor == 0 return 0 end number / divisor end #    function safe_division1(number, divisor) if divisor == 0 0 #             else number / divisor end end 

Für Funktionen mit einer kurzen Definition gibt es eine verkürzte Syntax ähnlich einer mathematischen Notation. Die Berechnung der Länge der Hypotenuse entlang der Länge der Beine kann also wie folgt definiert werden:

 hypotenuse(a, b) = sqrt(a^2 + b^2) 

Die "sichere" Unterteilung mit dem ternären Operator kann wie folgt geschrieben werden:

 safe_division(number, divisor) = divisor == 0 ? 0 : number / divisor 

Wie Sie sehen, müssen keine Typen für Funktionsargumente angegeben werden. Angesichts der Funktionsweise des Julia JIT-Compilers führt die Eingabe von Enten nicht immer zu einer schlechten Leistung.

Wie ich in einem früheren Artikel zu demonstrieren versucht habe, kann der Julia-Compiler den Typ des Rückgabeergebnisses anhand der Typen der Eingabeargumente ableiten. Daher erfordert die Funktion safe_division beispielsweise nur minimale Änderungen für einen schnellen Betrieb:

 function safe_division(number, divisor) if divisor == 0 return zero(number / divisor) end number / divisor end 

Wenn nun die Typen beider Argumente in der Kompilierungsphase bekannt sind, wird seitdem auch der Typ des zurückgegebenen Ergebnisses eindeutig angezeigt Die zero(x) -Funktion gibt einen Nullwert des gleichen Typs wie ihr Argument zurück (und die Division durch Null hat gemäß IEEE 754 einen darstellbaren Wert im Format von Gleitkommazahlen).

Funktionen können eine feste Anzahl von Positionsargumenten, Positionsargumente mit Standardwerten, benannte Argumente und eine variable Anzahl von Argumenten haben. Syntax:

 #    function hello(name) println("Hello, ", name) end #      #           function greeting_d(name, greeting = "Hello") println(greeting, ", ", name) end #       #          #       function greeting_kw(name; greeting = "Hello") println(greeting, ", ", name) end #  greeting   ,        function greeting_oblkw(name; greeting) println(greeting, ", ", name) end #      #  ,   ,      names function greeting_nary(greeting, names...) print(greeting) for name in names print(", ", name) end print('\n') end julia> hello("world") Hello, world julia> greeting_d("world") Hello, world julia> greeting_d("Mr. Smith", "How do you do") How do you do, Mr. Smith julia> greeting_kw("Mr. Smith") Hello, Mr. Smith julia> greeting_kw("mom", greeting = "Hi") Hi, mom julia> greeting_oblkw("world") ERROR: UndefKeywordError: keyword argument greeting not assigned Stacktrace: [1] greeting_oblkw(::String) at ./REPL[23]:3 [2] top-level scope at none:0 julia> greeting_oblkw("mom", greeting = "Hi") Hi, mom julia> greeting_nary("Hi", "mom", "dad", "everyone") Hi, mom, dad, everyone 

Stufe 2. Funktioniert als Daten

Der Name der Funktion kann nicht nur bei direkten Aufrufen verwendet werden, sondern auch als Kennung, mit der die Prozedur zum Abrufen des Werts verknüpft ist. Zum Beispiel:

 function f_x_x(fn, x) fn(x, x) end julia> f_x_x(+, 3) 6 # +(3, 3) = 3+3 = 6 julia> f_x_x(*, 3) 9 # *(3, 3) = 9 julia> f_x_x(^, 3) 27 # ^(3, 3) = 3^3 = 27 julia> f_x_x(log, 3) 1.0 # log(3, 3) = 1 

Die "klassischen" Funktionen, die ein funktionales Argument annehmen, sind map , reduce und filter .

map(f, x...) wendet die Funktion f auf die Werte aller Elemente aus x (oder Tupel von i-Elementen) an und gibt die Ergebnisse als neue Sammlung zurück:

 julia> map(cos, [0, π/3, π/2, 2*π/3, π]) 5-element Array{Float64,1}: 1.0 0.5000000000000001 6.123233995736766e-17 -0.4999999999999998 -1.0 julia> map(+, (2, 3), (1, 1)) (3, 4) 

reduce(f, x; init_val) "reduziert" die Sammlung auf einen einzelnen Wert und "erweitert" die Kette f(f(...f(f(init_val, x[1]), x[2])...), x[end]) :

 function myreduce(fn, values, init_val) accum = init_val for x in values accum = fn(accum, x) end accum end 

Da nicht wirklich bestimmt wird, in welcher Reihenfolge das Array während der Reduktion fn(accum, x) oder ob fn(accum, x) oder fn(x, accum) wird fn(x, accum) die Reduktion nur mit kommutativen oder assoziativen Operatoren wie der Addition ein vorhersagbares Ergebnis oder Multiplikation.

filter(predicate, x) gibt ein Array von x Elementen zurück, die das Prädikatprädikat erfüllen:

 julia> filter(isodd, 1:10) 5-element Array{Int64,1}: 1 3 5 7 9 julia> filter(iszero, [[0], 1, 0.0, 1:-1, 0im]) 4-element Array{Any,1}: [0] 0.0 1:0 0 + 0im 

Die Verwendung von Funktionen höherer Ordnung für Operationen an Arrays anstelle des Schreibens einer Schleife bietet mehrere Vorteile:

1. Der Code wird kürzer
2. map() oder reduce() zeigen die Semantik der ausgeführten Operation an. Dann müssen Sie noch die Semantik des Geschehens in der Schleife verstehen
3. map() kann der Compiler verstehen, dass Operationen an Array-Elementen unabhängig von Daten sind, wodurch zusätzliche Optimierungen angewendet werden können

Level 3. Funktioniert als Abstraktionen

In map() oder filter() Sie häufig eine Funktion verwenden, der kein eigener Name zugewiesen wurde. Mit Julia können Sie in diesem Fall die Abstraktion der Operationen für das Argument ausdrücken, ohne Ihren eigenen Namen für diese Sequenz einzugeben. Eine solche Abstraktion wird als anonyme Funktion oder Lambda-Funktion bezeichnet (da solche Funktionen in der mathematischen Tradition mit dem Buchstaben Lambda bezeichnet werden). Die Syntax für diese Ansicht lautet:

 #   square(x) = x^2 #   x -> x^2 #   hypot(a, b) = sqrt(x^2 + y^2) #   -    ,    , #              (x, y) -> sqrt(x^2 + y^2) #   fortytwo() = 42 #   () -> 42 julia> map(i -> map(x -> x^i, 1:5), 1:5) 5-element Array{Array{Int64,1},1}: [1, 2, 3, 4, 5] [1, 4, 9, 16, 25] [1, 8, 27, 64, 125] [1, 16, 81, 256, 625] [1, 32, 243, 1024, 3125] 

Sowohl benannte als auch anonyme Funktionen können Variablen zugewiesen und als Werte zurückgegeben werden:

 julia> double_squared = x -> (2 * x)^2 #17 (generic function with 1 method) julia> double_squared(5) 100 

Variabler Umfang und lexikalische Verschlüsse

Normalerweise versuchen sie, Funktionen so zu schreiben, dass alle für die Berechnung erforderlichen Daten durch formale Argumente erhalten werden, d. H. Alle im Hauptteil vorkommenden Variablennamen sind entweder die Namen formaler Argumente oder die Namen der Variablen, die im Funktionskörper eingeführt werden.

 function normal(x, y) z = x + y x + y * z end function strange(x, y) x + y * z end 

Über die normal() Funktion können wir sagen, dass in ihrem Körper alle Variablennamen verwandt sind , d.h. Wenn wir überall (einschließlich der Argumentliste) "x" durch "m" (oder einen anderen Bezeichner), "y" durch "n" und "z" durch "sum_of_m_and_n" ersetzen, ändert sich die Bedeutung des Ausdrucks nicht. In der Funktion strange() ist der Name z nicht verwandt , d.h. a) Die Bedeutung kann sich ändern, wenn dieser Name durch einen anderen ersetzt wird. b) Die Richtigkeit der Funktion hängt davon ab, ob zum Zeitpunkt des Aufrufs der Funktion eine Variable mit dem Namen „z“ definiert wurde.

Generell ist die normal() Funktion auch nicht so sauber:

1. Was passiert, wenn eine Variable mit dem Namen z außerhalb der Funktion definiert wird?
2. Die Zeichen + und * sind in der Tat auch nicht verwandte Bezeichner.

Mit Punkt 2 kann nichts anderes getan werden, als zuzustimmen - es ist logisch, dass Definitionen aller im System verwendeten Funktionen existieren müssen, und wir hoffen, dass ihre wahre Bedeutung unseren Erwartungen entspricht.

Punkt 1 ist weniger offensichtlich als es scheint. Tatsache ist, dass die Antwort davon abhängt, wo die Funktion definiert ist. Wenn es global definiert ist, ist z innerhalb von normal() eine lokale Variable, d.h. Selbst wenn es eine globale Variable z ihr Wert nicht überschrieben. Wenn sich die Definition der Funktion innerhalb des Codeblocks befindet, wird der Wert der externen Variablen geändert, wenn in diesem Block eine frühere Definition von z vorhanden ist.

Wenn der Funktionskörper den Namen einer externen Variablen enthält, wird dieser Name dem Wert zugeordnet, der in der Umgebung vorhanden war, in der die Funktion erstellt wurde. Wenn die Funktion selbst aus dieser Umgebung exportiert wird (z. B. wenn sie von einer anderen Funktion als Wert zurückgegeben wird), erfasst sie die Variable aus der internen Umgebung, auf die in der neuen Umgebung nicht mehr zugegriffen werden kann. Dies wird als lexikalischer Verschluss bezeichnet.

Abschlüsse sind hauptsächlich in zwei Situationen nützlich: Wenn Sie eine Funktion gemäß den angegebenen Parametern erstellen müssen und wenn Sie eine Funktion mit einem internen Status benötigen.

Betrachten Sie die Situation mit einer Funktion, die einen internen Zustand kapselt:

 function f_with_counter(fn) call_count = 0 ncalls() = call_count # invoke()  ,     #    ,  ncalls() function invoke(args...) call_count += 1 fn(args...) end #         # call_count     , #   invoke()  call_count()        (call = invoke, call_count = ncalls) end julia> abscount = f_with_counter(abs) (call = getfield(Main, Symbol("#invoke#22")){typeof(abs)}(abs, Core.Box(0)), call_count = getfield(Main, Symbol("#ncalls#21"))(Core.Box(0))) julia> abscount.call_count() 0 julia> abscount.call(-20) 20 julia> abscount.call_count() 1 julia> abscount.call(im) 1.0 julia> abscount.call_count() 2 

Fallstudie: alle gleichen Polynome

In einem früheren Artikel wurde die Darstellung von Polynomen als Strukturen betrachtet. Insbesondere ist eine der Speicherstrukturen eine Liste von Koeffizienten, beginnend mit der jüngsten. Um das Polynom p am Punkt x zu berechnen x vorgeschlagen, die Funktion evpoly(p, x) , die das Polynom nach dem Horner-Schema berechnet.


Die Darstellung eines Polynoms in Form einer Struktur entspricht nicht vollständig seinem intuitiven Verständnis als mathematische Funktion. Durch Rückgabe des Funktionswerts können Polynome aber auch direkt als Funktionen angegeben werden. So war es:

 struct Polynomial degree::Int coeff::NTuple{N, Float64} where N function Polynomial(v::T where T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}) #     /     P(x) ≡ 0 coeff = isempty(v) ? (0.0,) : tuple([Float64(x) for x in v]...) #   -   new #  -    return new(length(coeff)-1, coeff) end end """ evpoly(p::Polynomial, z::Real) Evaluate polynomial `p` at `z` using the Horner's rule """ function evpoly(p::Polynomial, z::Real) ans = p.coeff[end] for idx = p.degree:-1:1 ans = p.coeff[idx] + z * ans end return ans end 

Wir transformieren diese Definition in eine Funktion, die ein Array / Tupel von Koeffizienten verwendet und die tatsächliche Funktion zurückgibt, die das Polynom berechnet:

 function Polynomial_as_closure(v::T where T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}) #     /     P(x) ≡ 0 if isempty(v) return x::Real -> 0.0 end coeff = tuple(map(float, v)...) degree = length(coeff) - 1 function evpoly(z::Real) ans = coeff[end] for idx = degree:-1:1 ans = coeff[idx] + z * ans end return ans end evpoly end julia> p = Polynomial_as_closure((0, 1, 1)) # x² + x (::getfield(Main, Symbol("#evpoly#28")){Tuple{Float64,Float64,Float64},Int64}) (generic function with 1 method) julia> p(1) # ,    evpoly()! 2.0 julia> p(11) 132.0 

Ebenso können Sie eine Funktion für das Interpolationspolynom schreiben.

Eine wichtige Frage: Gab es etwas, das in der neuen Definition in der vorherigen Definition verloren gegangen ist? Leider gab das Festlegen des Polynoms als Struktur Hinweise für den Compiler und für uns die Möglichkeit, arithmetische Operatoren für diese Struktur zu überladen. Leider bietet Julia keine Funktionen eines so leistungsfähigen Typsystems.

Glücklicherweise können wir in diesem Fall das Beste aus beiden Welten herausholen, da Julia es Ihnen ermöglicht, sogenannte aufrufbare Strukturen zu erstellen. Das heißt, Sie können ein Polynom als Struktur angeben, es aber auch als Funktion aufrufen! Zu den Definitionen der Strukturen aus dem vorherigen Artikel müssen Sie lediglich Folgendes hinzufügen:

 function (p::Polynomial)(z::Real) evpoly(p, z) end function (p::InterpPolynomial)(z::Real) evpoly(p, z) end 

Mit funktionalen Argumenten können Sie auch einen externen Konstruktor eines Interpolationspolynoms für eine bestimmte Funktion hinzufügen, die aus einer Reihe von Punkten aufgebaut ist:

 function InterpPolynomial(fn, xsample::T) where {T<:Union{Vector{<:Real}, NTuple{<:Any, <:Real}}} InterpPolynomial(xsample, map(fn, xsample)) end 

Fazit

Die Möglichkeiten, die sich aus der funktionalen Programmierung in Julia ergeben, ergeben eine ausdrucksstärkere Sprache als ein rein imperativer Stil. Die Darstellung von Strukturen in Form von Funktionen ist eine bequemere und natürlichere Aufzeichnung mathematischer Konzepte.