algorithm - suggestions how to keep "calculated" a lot of "dependent" parameters -

i have several indicators need "always date". i.e. when changed need recalculate "dependent". have several levels each next level should calculated when previous level calculated. let me explain shining picture:

at point assume franc changed. should:

1. calc franc / dinar
2. calc franc / dinar / peso

or, if peso, franc , dinar changed @ once should:

1. calc franc / dinar
2. calc franc / dinar / peso
3. calc peso + euro / (euro + usd)

so whenever @ level 0 chagned should recalculate other levels. but

• we should calculate required items. if euro changed not need recalculate franc / dinar
• we should not calculate more once. if euro , usd changed @ once should calculate euro + usd once (not twice).

the straightforward solution be:

• store each level in array
• for each item in array track "listeners" next levels (could difficulty because example peso has listeners different levels - franc / dinar / peso level2 , peso + euro / (euro + usd) level 3, two-dimmension array required..)
• if item recalculated mark listeners recalculated too
• go level 0 last level , recalculate items marked recalculated (initially updated items market recalculated, example peso).

i guess problem kind of well-known , can suggest me general well-known solution. don't want reinvent wheel :) thanks!

i think level-based approach decent, on assumption listeners on lower level.

the idea:

have 2d array containing actual data, first index level, second position on level. let each element have willberecalculated flag.

have toberecalculated list each level (so array of lists).

for each element, have list of elements (the listeners) containing 2 integers - 1 level , 1 index.

for each element modified, add element toberecalculated on appropriate level , set willberecalculated true.

then go through toberecalculated first last level, recalculating each element, setting willberecalculated false and, each listener, looking applicable element, if willberecalculated true, nothing, otherwise, set willberecalculated true , add toberecalculated on (the listener's) level.

this approach doesn't go through data check needs modified / has been modified, checks applicable elements, , there no repeated calculations.

example:

for this:

(for abbreviations took first letter of each word. i'm using 0-indexed arrays)

actual data:

[[e, u, p, f, d],  [e+u, f/d],  [e/e+d, f/d/p],  [p+e/e+u] ] 

listeners:

e:[(1,0), (2,0)] // e+u , e/e+u u:[(1,0)] // e+u p:[(2,1), (3,0)] f:[(1,1)] d:[(1,1)] e+u:[(2,0)] f/d:[(2,1)] e/e+u:[(3,0)] 

modifying e , u:

add e , u toberecalculated[0] , set willberecalculated true both.

go through toberecalculated[0].

when modifying e, set willberecalculated false , set e+u's willberecalculated true , add toberecalculated[1] , set e/e+u's willberecalculated true , add toberecalculated[2].

when modifying u, set willberecalculated false , check e+u's willberecalculated , see it's true nothing.

then go through toberecalculated[1]. when modifying e+u, set willberecalculated false , check e/e+u's willberecalculated , see it's true nothing.

note:

it might better have listeners pointers elements instead of level , index variable.