Comment soustraire des éléments spécifiques dans une liste en utilisant la programmation fonctionnelle dans Mathematica?

Question

J'ai une liste des dates et des valeurs dans le format:

{{{dateInfo1},value1},{{dateInfo2},value2},...,{{dateInfoN},valueN}} 

Avec quelques dates et valeurs réelles:

{{{1971, 1, 31, 0, 0, 0.}, 1.0118}, {{1971, 2, 28, 0, 0, 0}, 1.0075}, 
..., {{2010, 5, 31, 0, 0, 0.}, 1.0403}} 

Pour les curieux, il y a une liste des États-Unis par rapport aux valeurs de $ CAD tiré du FRED database.

je voudrais soustraire simplement valeur1 à partir de la valeur 2, et puis créer une nouvelle liste avec les données sous la forme de:

{{{dateInfo1},0},{{dateInfo2},change1},...,{{dateInfoN},changeN-1}} 

(avec Évolution1 étant valeur2-valeur1)

Je sais qu'il doit y avoir une manière relativement facile de faire cela en utilisant la programmation fonctionnelle, par opposition à Do ou While avec des variables d'index et de comptage et tout ce non-sens. La méthode que j'essaie d'accomplir doit être relativement robuste, car j'insère automatiquement des ensembles de données provenant de sources qui ont la même mise en forme, mais avec des intervalles de temps différents. Le repositionnement est alors beaucoup plus facile si je n'ai pas besoin de spécifier les intervalles de date ListPlot (ce qui arriverait si je supprimais le dateInfo de la liste). Je connais le Centre de documentation et les capacités Mathematica hors programmation. J'ai appris la programmation avec Mathematica, et je veux vraiment étendre cette capacité à la programmation fonctionnelle, mais j'ai trouvé la plupart des ressources sur le sujet un peu trop difficile. J'ai l'impression d'être à cette bosse dans la courbe d'apprentissage où il est sur le point de se mettre en place, mais pour l'instant je me bats. À tout le moins, si vous avez une bonne source sur la programmation fonctionnelle, je serais plus qu'heureux de regarder dans ceux-ci! Toute aide est très appréciée! Désolé si c'est TMI, mais je suis sûr que beaucoup d'entre vous ont ressenti la même chose.

Answer 1

Vous avez une liste de paires {date, valeur}, donc si vous Transpose vous avez une liste de deux listes - la première une liste de dates et la seconde une liste de valeurs correspondantes. Vous pouvez ensuite prendre le Differences des valeurs, Prepend 0, puis Transposer à nouveau pour revenir à une liste de paires.

Dans le code,

data = {{{1971,1,31,0,0,0}, 1.0118}, 
     {{1971,2,28,0,0,0}, 1.0075}, 
     {{2010,5,31,0,0,0}, 1.0403}} 
{dates, values} = Transpose[data]; 
diffs = Prepend[Differences[values], 0]; 
answer = Transpose[{dates, diffs}] 

qui retourne:

{{{1971,1,31,0,0,0}, 0}, 
{{1971,2,28,0,0,0}, -0.0043}, 
{{2010,5,31,0,0,0}, 0.0328}} 

Pour conclure que en une seule fonction, avec grâce à Janus l'idée:

taildiffs[data_]:= 
    Transpose @ {#1, Prepend[Differences[#2], 0]}& @@ Transpose@data 

Notez que la construction ... #1 ... #2 ... & est une fonction pure:

http://reference.wolfram.com/mathematica/ref/Function.html

La syntaxe f@x est simplement un raccourci pour f[x].

Enfin, f@@list est un raccourci pour Apply[f, list]:

http://reference.wolfram.com/mathematica/ref/Apply.html

donc taildiffs tel que défini ci-dessus est juste un laconique (peut-être cryptique) version de ceci:

Apply[Transpose[Function[{x,y}, {x, Prepend[Differences[y],0]}], Transpose[data]] 

Answer 2

data = {{{dateInfo1}, value1}, {{dateInfo2}, value2}, {{dateInfo3}, value3}} 

Map[{#[[2,1]], #[[2,2]] - #[[1,2]]}&, {Take[data, Length[data] - 1], Rest[data]}] 

donne

{{{dateInfo2}, -value1 + value2}, {{dateInfo3}, -value2 + value3}} 

Ce premier élément dans la liste des résultats

{{dateInfo1},0} 

ne rentre pas vraiment dans la séquence, de sorte que vous pouvez manuellement préfixer à la liste

Answer 3

Je recommande d'utiliser Reap et Sow pour cela:

In[13]:= lis= {{{1971,1,31,0,0,0.},1.0118},{{1971,2,28,0,0,0},1.0075},{{2010,5,31,0,0,0.},1.0403}}; 

In[14]:= First@Last@Reap[ 
    (* set first previous to first value to get 0 *) 
    Module[{prev = lis[[1, 2]]}, 
    Scan[ 
    (
     (* First[#] = date, Last[#] = value *) 
     Sow[{First[#], Last[#] - prev}]; 
     (* set new previous to this value *) 
     prev = Last[#] 
     ) &, 
    lis]] 
    ] 

Out[14]= {{{1971, 1, 31, 0, 0, 0.}, 0.}, 
    {{1971, 2, 28, 0, 0, 0}, -0.0043}, 
    {{2010, 5, 31, 0, 0, 0.}, 0.0328}} 

La sortie de Reap est un peu compliqué si vous n'êtes pas familier avec elle, mais Reap et Sow vous donnent essentiellement un moyen de « semer » les choses dans des listes, puis les « récolter » après l'évaluation. Reap et Sow sont beaucoup plus efficaces que d'utiliser AppendTo avec une liste, par exemple.

HTH!

Answer 4

A l'exception du fait que vous voulez l'initiale 0, vous cherchez Differences. Pour quitter les dates seul, transposent et appliquent à la deuxième partie seulement, comme ceci:

TailDifferences[data_]:= 
    Transpose@Apply[{#1,{0}~Join~Differences[#2]}&,Transpose[data]] 

Appliqué à vos données fournissent quelque chose comme ceci:

data={{{dateInfo1},value1},{{dateInfo2},value2},{{dateInfo3},value3}}; 
TailDifferences[data] 

{{{dateInfo1},0},{{dateInfo2},-value1+value2},{{dateInfo3},-value2+value3}} 

Answer 5

Cette opération pourrait également être fait avec Part et Set:

data = {{{1971,1,31,0,0,0}, 1.0118}, 
     {{1971,2,28,0,0,0}, 1.0075}, 
     {{2010,5,31,0,0,0}, 1.0403}}; 

Module[{a = data}, 
    a[[2 ;;, 2]] = Differences[a[[All, 2]]]; 
    a[[1, 2]] = 0; 
    a 
] 

{{{1971, 1, 31, 0, 0, 0}, 0}, 
{{1971, 2, 28, 0, 0, 0}, -0.0043}, 
{{2010, 5, 31, 0, 0, 0}, 0.0328}}