Julia: funções e estruturas-como-funções

Apesar do conceito de Julia carecer de programação orientada a objetos “clássica” com classes e métodos, a linguagem fornece ferramentas de abstração, um papel fundamental desempenhado pelo sistema de tipos e pelos elementos da programação funcional. Vamos considerar o segundo ponto em mais detalhes.

O conceito de funções em Julia é provavelmente o mais semelhante aos idiomas da família Lisp (para ser mais preciso, os ramos Lisp-1), e as funções podem ser consideradas em três níveis: como subprogramas, como abstrações para uma determinada sequência de ações e como dados que representam essa abstração. .

Nível 1. Funções como rotinas

A alocação de subprogramas e a atribuição de nomes próprios vem ocorrendo desde os tempos pré-históricos, quando o Fortran era considerado um idioma de alto nível e C ainda não existia.

Nesse sentido, os produtos Julia são padrão. Pode-se chamar “recurso” o fato de que sintaticamente não há divisão em procedimentos e funções. Independentemente de a sub-rotina ser chamada para obter algum valor ou apenas para executar alguma ação nos dados, ela é chamada de função.

A definição de uma função começa com a palavra-chave function , seguida por uma lista de argumentos, uma sequência de comandos entre colchetes e a palavra end termina a definição:

 """ 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 

A sintaxe é diferenciada pelo comportamento herdado do Lisp: para um retorno "normal" de um valor de uma função, a palavra return não return necessária: o valor da última expressão calculada antes do end retorno. No exemplo acima, o valor da variável sum será retornado. Assim, o return pode ser usado como um marcador do comportamento especial de uma função:

 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 

Para funções com uma definição curta, há uma sintaxe abreviada semelhante a uma notação matemática. Portanto, o cálculo do comprimento da hipotenusa ao longo do comprimento das pernas pode ser definido da seguinte forma:

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

A divisão "segura" usando o operador ternário pode ser escrita da seguinte maneira:

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

Como você pode ver, não é necessário especificar tipos para argumentos de função. Dado como o compilador Julia JIT funciona, a digitação com patos nem sempre resulta em baixo desempenho.

Como tentei demonstrar em um artigo anterior , o compilador Julia pode inferir o tipo do resultado do retorno pelos tipos de argumentos de entrada. Portanto, por exemplo, a função safe_division requer modificações mínimas para operação rápida:

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

Agora, se os tipos de ambos os argumentos forem conhecidos no estágio de compilação, o tipo do resultado retornado também será exibido sem ambiguidade, pois a função zero(x) retorna um valor zero do mesmo tipo que seu argumento (e a divisão por zero, de acordo com a IEEE 754 , tem um valor perfeitamente representável no formato de números de ponto flutuante).

As funções podem ter um número fixo de argumentos posicionais, argumentos posicionais com valores padrão, argumentos nomeados e um número variável de argumentos. Sintaxe:

 #    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 

Nível 2. Funções como Dados

O nome da função pode ser usado não apenas em chamadas diretas, mas também como um identificador ao qual o procedimento para obter o valor está associado. Por exemplo:

 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 

As funções "clássicas" que usam um argumento funcional são map , reduce e filter .

map(f, x...) aplica a função f aos valores de todos os elementos de x (ou tuplas de elementos i) e retorna os resultados como uma nova coleção:

 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) "reduz" a coleção para um único valor, "expandindo" a cadeia 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 

Como não é realmente determinado em que ordem a matriz passará durante a redução ou se fn(accum, x) ou fn(x, accum) serão fn(x, accum) , a redução fornecerá um resultado previsível apenas com operadores comutativos ou associativos, como adição ou multiplicação.

filter(predicate, x) retorna uma matriz de x elementos que satisfazem o predicado predicate :

 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 

O uso de funções de ordem superior para operações em matrizes em vez de gravar um loop tem várias vantagens:

1. o código está ficando mais curto
2. map() ou reduce() mostram a semântica da operação que está sendo executada, então você ainda precisa entender a semântica do que está acontecendo no loop
3. map() permite que o compilador entenda que as operações nos elementos da matriz são independentes dos dados, o que permite que otimizações adicionais sejam aplicadas

Nível 3. Funções como Abstrações

Frequentemente, no map() ou no filter() você precisa usar uma função que não recebeu seu próprio nome. Julia, nesse caso, permite expressar a abstração das operações no argumento, sem inserir seu próprio nome para esta sequência. Essa abstração é chamada de função anônima ou função lambda (uma vez que, na tradição matemática, essas funções são denotadas pela letra lambda). A sintaxe para esta visualização é:

 #   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] 

As funções nomeadas e anônimas podem ser atribuídas a variáveis ​​e retornadas como valores:

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

Escopo variável e fechamentos lexicais

Normalmente, eles tentam escrever funções de forma que todos os dados necessários para o cálculo sejam obtidos através de argumentos formais, ou seja, quaisquer nomes de variáveis ​​que ocorrem no corpo são os nomes dos argumentos formais ou os nomes das variáveis ​​introduzidas no corpo da função.

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

Sobre a função normal() , podemos dizer que em seu corpo todos os nomes de variáveis ​​estão relacionados , ou seja, se em qualquer lugar (incluindo a lista de argumentos) substituirmos "x" por "m" (ou qualquer outro identificador), "y" por "n" e "z" por "sum_of_m_and_n", o significado da expressão não será alterado. Na função strange() , o nome z não é relacionado , ou seja, a) o significado pode mudar se esse nome for substituído por outro eb) a correção da função depende se uma variável com o nome “z” foi definida no momento em que a função foi chamada.

De um modo geral, a função normal() também não é tão limpa:

1. O que acontece se uma variável chamada z for definida fora da função?
2. Os caracteres + e *, de fato, também são identificadores não relacionados.

Com o ponto 2, nada pode ser feito senão concordar - é lógico que definições de todas as funções usadas no sistema devam existir, e esperamos que seu significado real corresponda às nossas expectativas.

O ponto 1 é menos óbvio do que parece. O fato é que a resposta depende de onde a função está definida. Se for definido globalmente, z dentro de normal() será uma variável local, ou seja, mesmo se houver uma variável global z seu valor não será substituído. Se a definição da função estiver dentro do bloco de código, se houver uma definição anterior de z nesse bloco, será o valor da variável externa que será alterada.

Se o corpo da função contiver o nome de uma variável externa, esse nome será associado ao valor que existia no ambiente em que a função foi criada. Se a função em si for exportada desse ambiente (por exemplo, se ela for retornada de outra função como um valor), ela "captura" a variável do ambiente interno, que não está mais acessível no novo ambiente. Isso é chamado de fechamento lexical.

Os fechamentos são úteis principalmente em duas situações: quando você precisa criar uma função de acordo com os parâmetros fornecidos e quando você precisa de uma função que tenha algum estado interno.

Considere a situação com uma função que encapsula um estado interno:

 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 

Estudo de caso: todos os mesmos polinômios

Em um artigo anterior, a apresentação de polinômios como estruturas é considerada. Em particular, uma das estruturas de armazenamento é uma lista de coeficientes, começando pelos mais jovens. Para calcular o polinômio p no ponto x proposta a função evpoly(p, x) , que calcula o polinômio de acordo com o esquema de Horner.


A representação de um polinômio na forma de uma estrutura não corresponde totalmente à sua compreensão intuitiva como uma função matemática. Porém, retornando o valor funcional, os polinômios também podem ser especificados diretamente como funções. Então foi:

 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 

Transformamos essa definição em uma função que pega uma matriz / tupla de coeficientes e retorna a função real que calcula o polinômio:

 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 

Da mesma forma, você pode escrever uma função para o polinômio de interpolação.

Uma pergunta importante: havia algo que se perdeu na nova definição da definição anterior? Infelizmente, sim - definir o polinômio como uma estrutura deu dicas para o compilador e, para nós, a capacidade de sobrecarregar operadores aritméticos para essa estrutura. Infelizmente, Julia não fornece funções para um sistema de tipos tão poderoso.

Felizmente, nesse caso, podemos tirar o melhor dos dois mundos, pois Julia permite que você crie as chamadas estruturas que podem ser chamadas. I.e. Você pode especificar um polinômio como uma estrutura, mas pode chamá-lo como uma função! Para as definições de estruturas do artigo anterior, você só precisa adicionar:

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

Usando argumentos funcionais, você também pode adicionar um construtor externo de um polinômio de interpolação para uma determinada função construída a partir de um conjunto de pontos:

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

Conclusão

As possibilidades emprestadas da programação funcional em Julia fornecem uma linguagem mais expressiva em comparação com um estilo puramente imperativo. A representação de estruturas na forma de funções é uma forma de registro mais conveniente e natural de conceitos matemáticos.