Come sottrarre elementi specifici in un elenco utilizzando la programmazione funzionale in Mathematica?

Question

Ho un elenco di date e valori nel formato:

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

Con alcune date e valori effettivi:

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

Per chi fosse curioso, si tratta di un elenco di Stati Uniti contro valori CAD $ tirato dallo FRED database.

vorrei sottrarre semplicemente valore1 dal valore di 2, e quindi creare un nuovo elenco con i dati sotto forma di:

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

(con change1 essendo valore2-valore1)

So che ci deve essere un modo relativamente semplice per farlo usando la programmazione funzionale, al contrario di Do o While con le variabili indice e il conteggio e tutte quelle sciocchezze. Il metodo che sto cercando di realizzare deve essere relativamente robusto, perché sto prelevando automaticamente i set di dati da fonti che hanno la stessa formattazione, ma intervalli di tempo diversi. Sostituire è quindi molto più semplice se non devo specificare gli intervalli di data di ListPlot (cosa che accadrebbe se togliessi la dataInfo dall'elenco).

Ho familiarità con il Centro di documentazione e le capacità di Mathematica non programmabili. Ho imparato a programmare con Mathematica e voglio davvero estendere tale capacità alla programmazione funzionale, ma ho trovato la maggior parte delle risorse sull'argomento un po 'troppo difficile. Mi sento come se fossi a quella gobba nella curva di apprendimento in cui sta per scattare in posizione, ma in questo momento sto lottando. Per lo meno, se hai una buona fonte di programmazione funzionale, sarei più che felice di esaminarli! Ogni aiuto è molto apprezzato! Scusa se è TMI, ma sono sicuro che molti di voi si sono sentiti allo stesso modo.

Answer 1

Hai un elenco di {date, value} coppie, quindi se hai Transpose avrai un elenco di due elenchi: il primo un elenco di date e il secondo un elenco di valori corrispondenti. È quindi possibile prendere lo Differences dei valori, Prepend 0, quindi Trasporre nuovamente per tornare a un elenco di coppie.

Nel codice,

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

che ritorna:

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

Per concludere che fino in una singola funzione, con grazie al Janus per l'idea:

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

Si noti che il costrutto ... #1 ... #2 ... & è una pura funzione:

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

Il f@x sintassi è semplicemente una scorciatoia per f[x].

Infine, f@@list è una scorciatoia per Apply[f, list]:

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

Così taildiffs come sopra definito è solo una versione stringata (forse criptico) di questo:

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

dà

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

Questo primo elemento nella lista dei risultati

{{dateInfo1},0} 

non si adatta davvero in sequenza, in modo da poter anteporre manualmente all'elenco

Answer 3

Si consiglia di utilizzare Reap e Sow per questo:

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

L'uscita del Reap è un po 'complicato se non si ha familiarità con esso, ma Reap e Sow fondamentalmente si invia un modo per "seminare" le cose in liste e poi "raccogliere" loro dopo la valutazione. Reap e Sow sono molto più efficienti rispetto all'utilizzo di AppendTo con un elenco, ad esempio.

HTH!

Answer 4

Fatta eccezione per il fatto che vuoi l'iniziale 0, stai cercando Differences. Per lasciare le date da solo, recepire e ad applicare solo alla seconda parte, in questo modo:

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

Applicando questo ai dati cede qualcosa di simile:

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

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

Answer 5

Questa operazione potrebbe essere fatto anche con Part e 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}}