Prenez le vecteur des inconnues et appliquez une fonction générique différenciable . Le jacobien est alors donné par une matrice telle que:

Par exemple, supposez m=3et n=2. Ensuite (en utilisant l'indexation basée sur 0)

Le jacobien de fest alors

Le but de ce défi est d'imprimer cette matrice jacobienne.

Contribution

Votre programme / fonction doit prendre en entrée deux entiers positifs met n, qui représentent le nombre de composants de fet urespectivement. L'entrée peut provenir de n'importe quelle source souhaitée (stdio, paramètre de fonction, etc.). Vous pouvez dicter l'ordre dans lequel ceux-ci sont reçus, et cela doit être cohérent pour toute entrée dans votre réponse (veuillez préciser dans votre réponse).

Production

Quelque chose qui représente la matrice jacobienne. Cette représentation doit énoncer explicitement tous les éléments de la matrice jacobienne, mais la forme exacte de chaque terme est définie par l'implémentation tant qu'il est sans ambiguïté ce qui est différencié et par rapport à quoi, et chaque entrée est sortie dans un ordre logique. Exemples de formes acceptables pour représenter une matrice:

1. Une liste de listes où chaque entrée de la liste extérieure correspond à une ligne du jacobien, et chaque entrée de la liste intérieure correspond à une colonne du jacobien.
2. Une chaîne ou une sortie textuelle où chaque ligne est une ligne du jacobien et chaque entrée séparée par un délimiteur dans une ligne correspond à une colonne du jacobien.
3. Quelques représentations graphiques / visuelles d'une matrice. Exemple: ce qui est montré par Mathematica lors de l'utilisation de la MatrixFormcommande
4. Un autre objet de matrice dense où chaque entrée est déjà stockée en mémoire et peut être interrogée (c'est-à-dire que vous ne pouvez pas utiliser un objet générateur). Un exemple serait la façon dont Mathematica représente en interne un objet Matrix

Exemples de formats d'entrée:

1. Une chaîne de la forme d f_i/d u_j, où iet jsont des entiers. Ex: d f_1/d u_2. Notez que ces espaces entre det f_1ou x_2sont facultatifs. De plus, les traits de soulignement sont également facultatifs.
2. Une chaîne de la forme d f_i(u_1,...,u_n)/d u_jou d f_i(u)/d u_j. Autrement dit, les paramètres d'entrée du composant fonction f_isont facultatifs et peuvent être explicitement expliqués ou laissés sous forme compacte.
3. Une sortie graphique formatée. Ex.: Ce que Mathematica imprime lorsque vous évaluez l'expressionD[f_1[u_,u_2,...,u_n],u_1]

Vous pouvez choisir pour quoi l'index de départ uet fsont (veuillez préciser dans votre réponse). La sortie peut être vers n'importe quel récepteur souhaité (stdio, valeur de retour, paramètre de sortie, etc.).

Cas de test

Les cas de test suivants utilisent la convention m,n. Les index sont affichés sur la base de 0.

1,1
[[d f0/d u0]]

2,1
[[d f0/d u0],
 [d f1/d u0]]

2 2
[[d f0/d u0, d f0/d u1],
 [d f1/d u0, d f1/d u1]]

1,2
[[d f0/d u0, d f0/d u1]]

3,3
[[d f0/d u0, d f0/d u1, d f0/d u2],
 [d f1/d u0, d f1/d u1, d f1/d u2],
 [d f2/d u0, d f2/d u1, d f2/d u2]]

Notation

C'est le golf de code; le code le plus court en octets gagne. Les failles standard sont interdites. Vous êtes autorisé à utiliser toutes les fonctions intégrées souhaitées.

Python, 63 octets

lambda m,n:["df%d/du%%d "%i*n%tuple(range(n))for i in range(m)]

Pour m=3,n=2, sorties

['df0/du0 df0/du1 ', 'df1/du0 df1/du1 ', 'df2/du0 df2/du1 ']

Le formatage des chaînes est 1 octet plus court que le plus évident

lambda m,n:[["df%d/du"%i+`j`for j in range(n)]for i in range(m)]

R, 93 78 octets

function(M,N){v=vector();for(i in 1:N){v=cbind(v,paste0("df",1:M,"/du",i))};v}

La numérotation est basée sur 1.

-15 octets grâce à @AlexA. remaks!

Maxima, 68 octets

C'est dommage que je ne connaisse pas Maxima comme je connais mon cher C et Matlab. Mais je vais essayer néanmoins.

f(m,n):=(x:makelist(x[i],i,m),g:makelist(g[i](x),i,n),jacobian(g,x))

Exemple de session utilisant TeXmacs comme interprète Maxima, principalement pour un rendu mathématique soigné:

Il peut très bien y avoir de meilleures façons de faire des listes et autres dans Maxima (je voudrais surtout faire apparaître les fonctions sans les marqueurs de liste, []), mais je ne connais pas assez bien le langage.

Rubis, 53 octets

fest indexé 0, uest indexé 1. Essayez-le en ligne!

->m,n{m.times{|i|p (1..n).map{|j|"d f#{i}/d u#{j}"}}}

Chaque ligne occupe une ligne en tant que représentation de tableau, comme illustré ci-dessous. S'il n'est pas conforme aux spécifications, faites-le moi savoir et je le corrigerai.

["d f0/d u1", "d f0/d u2", "d f0/d u3"]
["d f1/d u1", "d f1/d u2", "d f1/d u3"]

Cheddar , 79 49 octets

m->n->(|>m).map(i->(|>n).map(j->"df%d/du%d"%i%j))

Apparemment une fourchette de cette réponse .

Pour les 3,2retours:

[["df0/du0", "df0/du1", "df0/du2"], ["df1/du0", "df1/du1", "df1/du2"]]

Gelée, 18 octets

ps⁴’“ df“/du”ż$€€G

Essaye le!

Étant donné (m, n) = (3, 2) , imprime (avec des espaces marqués comme ·:)

·df0/du0·df0/du1
·df1/du0·df1/du1
·df2/du0·df2/du1

C, 125 octets:

main(w,y,b,q){scanf("%d %d",&w,&y);for(b=0;b<w;b++){for(q=0;q<y;q++)printf("d f%d/du u%d%s",b,q,q<y-1?", ":"");printf("\n");}}

Prend l'entrée sous la forme de 2 entiers séparés par des espaces b yet génère la matrice jacobienne sous yforme de chaînes séparées par des virgules sur les blignes.

C It Online! (Ideone) ou Test Suite (Ideone)