Question simple, donnée une liste comme celle-ci et supposons que j'ai une fonction définie comme ceci: p> et je veux Pour appliquer cette fonction à la liste, donc si je tape p> ceci donne p> je veux qu'il sort AS P> MapThread[foo, Transpose[lst]]
{foo[a, b], foo[c, d], foo[e, f]}
5 Réponses :
Vous avez besoin appliquer au niveau niveau 1 ou son formulaire court, @@@
Un moyen possible de changer la tête de chaque élément de lst de list à foo :
Quelques possibilités de choix de:
Celui-ci est une version plus verbeuse de la réponse de Yoda. Il applique FOO code> au niveau 1 de la liste lst code> uniquement (remplace la liste code> avec la tête foo code>): P> Replace[lst, List[x__] -> foo[x], 1]
juste pour signaler des tests de performance déroutants des deux méthodes ( @@@ code>, @@ # & / / @ code>): Table[{ToString[F], H[F, T]}, {F, {Plus, Subtract, Times, Divide, Power, Log}}]
Out[15]= {{"Plus", 0.2898246},
{"Subtract", 0.2979452},
{"Times", 0.2721893},
{"Divide", 0.3078512},
{"Power", 0.3321622},
{"Log", 0.3258972}}
Pas si déroutant si nous rappelons que carte autocompiles quand il peut, et appliquer peut être compilé pour seulement 3 têtes: plus , fois et liste . OTOH, @@@ n'est pas autocomple. Vous voyez l'efficacité des boosts pour plus et fois en raison de l'autocompilation dans l'autocompilation dans le @@ # & / / @ construction, et parce que votre entrée est une grande emballée. Array (qui permet de bénéficier d'une autocompilation)
Voir aussi cette réponse de la mienne: Stackoverflow.com/questions/6405304/... et les commentaires ci-dessous, pour plus de discussions sur des questions similaires.
@Leonid merci pour un lien intéressant et des commentaires. En effet, lorsque j'évalue la fonction h sur t1 = fromPackedarray [t] efficacité relative de plus et fois ralentit Down à peu près par le facteur 2, tandis que l'autre fonctionne que par quelques percents, cependant mappe est toujours presque deux fois plus rapide pour plus et fois . La raison de cet effet est apparemment une autocompilation. D'autre part, des remarques sur les attributs des fonctions connexes sont toujours valables et j'espère qu'il ne devrait y avoir aucune sorte de malentendu.
Franchement, je pense que l'autocompilation est la raison Sole de la différence de performance, tandis que d'autres attributs que vous mentionnez ne le contribuent pas dans ce cas particulier. Pour voir cela, exécuter SetSystemOptions ["Compileoptions" -> "MapCompilelLength" -> Infinity] - Cela désactive efficacement la compilation automatique. Ensuite, redo de vos horaires et vous verrez que fois et plus se comportent maintenant de même que le reste (assurez-vous de restaurer "MapCompilLelength" à sa valeur par défaut (100)). Pour Assurez-vous que les attributs peuvent faire une différence, mais pas dans ce cas, je suppose.
Merci pour des commentaires utiles. Que faire au cas où l'on souhaite définir une autre carte de plancompilel, ... option inspecteur? Je suppose que cela n'est pas recommandé. Avez-vous essayé de le faire?
Pour descendre, pourriez-vous être plus précis ce qui ne va pas dans ma réponse ou ce qui peut être amélioré?
En fait, je n'ai jamais essayé de changer cette option globalement. Une chose que vous pouvez faire est de placer le SetSystemoptions ["Compileoptions" -> "MapCompilLelength" -> Votre valeur] Ligne dans votre init.m (celui pour le noyau ). Mais pourquoi déranger? La valeur par défaut semble très sensible et pourquoi voudriez-vous le changer? La compilation est au code d'octet et ne prend pas cela beaucoup de temps, tout en améliorant généralement l'efficacité du code.
Je n'ai pas l'intention de modifier des valeurs par défaut des systèmesOptions, mais je me demandais quoi faire en cas de besoin. Conditionnellement, comme on pouvait déduire de mon poste, il serait utile de certaines tâches de calcul sérieuses.
Le seul itinéraire à modifier, je suis au courant du document SetSystemoptions . Peut être il y a d'autres moyens.
Les réponses sur La tête de séquence est ce qui reste naturellement si une tête de toute liste de paramètres est supprimée, donc donc Alternativement, appliquer [] sont sur place et est la bonne chose à faire, mais ce que vous essayiez de faire, était de remplacer une liste [] tête avec une séquence [] tête, ie Liste [Liste [3,5], liste [6,7]] devrait devenir liste [Séquence [3, 5], séquence [6,7]] .
Suppr [plus [3,5], 0] et Suppr [{3,5} , 0] et Suppr [Liste [3,5], 0] produirait tous la séquence [3,5] . .
foo @ supprimer [#, 0] & / @ {{a, b}, {e, f}} vous donnera la même chose que foo@@ {{a, b}, {c, d}, {e, f}} .
foo [# /. List -> séquence] & / {{{A, B}, {C, D}, {E, F}} fait la même chose. < / p>
Je dois être en désaccord avec la déclaration qu'il souhaite activer Liste [liste [...] ..] dans la liste [...] [...] ..] . Plus correctement, il veut Liste [F [...] ..] , c'est-à-dire, il souhaite modifier les têtes des listes intérieures vers f .
Je conviens que c'est ce qu'il "veut". Je voulais dire cela dans un sens "Ce que tu veux faire pour y arriver, c'est ..." ;-) Désolé pour la confusion. Pour accéder à List [F [Séquence [...]], ...] Il avait besoin d'un moyen de convertir une liste de listes vers une liste de séquences. Appliquer le fait en interne.
associé Question: Appliquer la liste des arguments à Mathematica