Plusieurs types pour une fonction Julia
Bonjour
Dans Julia on n'est pas obligé de typer les arguments des fonctions, mais je préfère le faire.
J'ai une fonction
En outre, je définis dans ma fonction Jack une autre fonction, appelée jac:
Dans Julia on n'est pas obligé de typer les arguments des fonctions, mais je préfère le faire.
J'ai une fonction
function Jack(x::Array{Float64,1}, lambda::Array{Int64,1}, alpha::Float64)
Je voudrais aussi qu'elle marche avec ces types:
function Jack(x::Array{Rational{Int64},1}, lambda::Array{Int64,1}, alpha::Rational{Int64})
Comment faire ça ?En outre, je définis dans ma fonction Jack une autre fonction, appelée jac:
function Jack(x::Array{Float64,1}, lambda::Array{Int64,1}, alpha::Float64)
function jac(m::Int64, k::Int64, mu::Array{Int64,1}, nu::Array{Int64,1}, beta::Float64)
...
Je voudrais que lorsqu'on utilise Jack avec du Rational{Int64}, le beta de jac soit un Rational{Int64}. Je ne sais pas si je suis clair là ? Connectez-vous ou Inscrivez-vous pour répondre.
Réponses
function Jack(x::Array{T,1}, lambda::Array{Int64,1}, alpha::T) where T<:Real function jac(m::Int64, k::Int64, mu::Array{Int64,1}, nu::Array{Int64,1}, beta::T) .......2ème question) pas très claire. Telle que tu l'as écrite, jac ne peux être appelée que par Jack. Pourquoi ne pas mettre le bon type ?
Sinon: la conversion de type, ça marche: tape Rational(1.0); il va te répondre 1//1 .
En revanche Rational(pi) te balancera une erreur.
Voilà mon prog, pour que la 2ème question soit plus claire, et si tu as d'éventuelles remarques.
function fi(lambda::Array{Int64,1}) out = Int64[] n = size(lambda,1) for i in range(1, stop=n) out = vcat(out, repeat([lambda[i ]], i)) end return out end function fj(lambda::Array{Int64,1}) out = Int64[] mu = filter(x -> x>0, lambda) n = size(mu,1) for m in mu out = vcat(out, 1:m) end return out end function dualPartition(lambda::Array{Int64,1}) out = Int64[] for i in 1:lambda[1] out = push!(out, size(filter(x -> x>=i, lambda), 1)) end return out end function betaratio(kappa::Array{Int64,1}, mu::Array{Int64,1}, k::Int64, alpha::T) where T<:Real muk = mu[k] t = k - alpha * muk u = map(i -> t + 1 - i + alpha * kappa[i ], 1:k) v = map(i -> t - i + alpha * mu[i ], 1:(k-1)) muPrime = dualPartition(mu) w = map(i -> muPrime[i ] - t - alpha * i, 1:(muk-1)) prod1 = prod(map(x -> x/(x+alpha-1), u)) prod2 = prod(map(x -> (x+alpha)/x, v)) prod3 = prod(map(x -> (x+alpha)/x, w)) return alpha * prod1 * prod2 * prod3 end function fN(lambda::Array{Int64,1}, mu::Array{Int64,1}) prods = map(i -> prod(Iterators.drop(lambda .+ 1, i)), 1:size(lambda,1)) return sum(map((x,y) -> x*y, mu, prods)) end function Jack(x::Array{T,1}, lambda::Array{Int64,1}, alpha::T) where T<:Real function jac(m::Int64, k::Int64, mu::Array{Int64,1}, nu::Array{Int64,1}, beta::T) if (size(nu,1)==0 || nu[1]==0 || m==0) return convert(T,1) end if (size(nu,1)>m && nu[m+1]>0) return convert(T,0) end if (m==1) return x[1]^(nu[1]) * prod(1 .+ alpha .* collect(1:(nu[1]-1))) end v = S[fN(lambda,nu),m] if (k == 0 && !isnan(v)) return v end i = max(1,k) s = jac(m-1, 0, nu, nu, convert(T,1)) * beta * x[m]^(sum(mu)-sum(nu)) while (length(nu) >= i && nu[i ] > 0) if (length(nu) == i && nu[i ] > 0 || nu[i ] > nu[i+1]) nuPrime = copy(nu) nuPrime[i,1] = nu[i,1] - 1 gamma = beta * betaratio(mu, nu, i, alpha) if (nu[i ] > 1) s = s + jac(m, i, mu, nuPrime, gamma) else s = s + jac(m-1, 0, nuPrime, nuPrime, convert(T,1)) * gamma * x[m]^(sum(mu)-sum(nuPrime)) end end i += 1 end if k == 0 S[fN(lambda,nu), m] = s end return s end S = fill(NaN, (fN(lambda,lambda), size(x,1))) jac(size(x,1), 0, lambda, lambda, convert(T,1)) endCeci dit, quitte à typer, sauf si tu as des raisons très sérieuses de le faire; il est sans doute plus raisonnable de typer avec des types abstraits, mettons Integer plutôt que Int64.
Je suis accro au typage depuis que je me suis mis à Haskell. Mais le système de typage de Haskell me semble mieux élaboré.
Là je suis un peu obligé : je veux utiliser Jack soit avec du Float soit avec du Rational. Dans R, j'ai dû faire une fonction pour chaque type.
Il n'y a pas de typage dans R (mon langage quotidien) et je ne trouve ça pas cool. Imagine f(n) où n doit être un entier. Que se passe-t-il si l'utilisateur entre un non-entier ? Il faut tester, faire un truc du genre:
f <- function(n){ if(floor(n) != n) stop("n must be an integer") ...... }Pas besoin de faire ça avec le typage.
Et puis c'est plus sympa pour le lecteur du code.
Je viens de tester Jack. Il semble que l'implémentation Julia pulvérise mon implémentation Haskell (en rapidité). Mais je ne suis pas une star en Haskell, peut-être que ma prog n'est pas optimale.
typeof(a) <: Integer
(false pour a=1.0)
ou
isinteger(a)
true pour a=1.0
Finalement, j'ai comparé avec une autre de mes implémentations Haskell, ça semble comparable en rapidité. Dur à dire sans faire des benchmarks.
J'initialise le tableau S à la fin de la fonction Jack: NaN est de type Float64.
Puis le prog, quand je l'utilise avec des Rational, remplit ce tableau avec des Rational. Et il retourne bien un Rational à la fin: Or, quand on met un Rational dans un tableau Float64, le Rational est automatiquement converti en Float64. Je ne comprends donc pas pourquoi Jack retourne quand même un Rational.
S = Array{Union{Missing, T}}(missing, fN(lambda,lambda), size(x,1))et isnan par ismissing. Voilà qui est clean, maintenant.Jack([1//3;2//1;1],[0;3;4],5//1)
passe, mais pas
Jack([1//3;2//1;1],[0;3;4],5)
> Jack([1//3;2//1;1],[0;3;4],5//1)
Attention aléa, le deuxième argument doit être une partition d'un entier: un vecteur d'entiers >0 rangés en ordre décroissant. Sinon je ne sais pas ce que sort le code 8-) et faudra pas se plaindre si tout crashe ;-)
Je peux peut-être faire alpha = T(alpha).
julia> Rational{Int64}(1) 1//1https://docs.julialang.org/en/v1/manual/conversion-and-promotion/index.html
Moralement, il me semble que T(x) ne doit être utilisé que quand le programmeur sait parfaitement ce qu'il y a dans x.
Quand j'ai lu T() dans des codes, c'était souvent T(1) ou T(0).