Workflow: Handling discretized aggregations

[OAGr]

One common workflow is something like,

"I can expect my stock earnings to change by (-3% to 8%) each year. I want these draws to be independent. I want to see a simulation for this, over the next 20 years".

Arguably, it would be better if this person would find an analytical solution to this to solve for each point in time, but sometimes this is a burden.

Here's some code that can do one version of this, but is of course sort of clunky (reduce takes some getting used to)

a = 1
yearlyChange() = SampleSet.fromDist(0.1 to 0.3)

c = reduce(
  List.make(10, 1),
  [mx(1)],
  {|acc, value|{
    newValue = List.last(acc) * (1 + yearlyChange())
    List.append(acc, newValue)
  }}
)

f(t) = c[floor(t)]

I imagine the first thing we want is some Plot function that can show discrete values. It's given some data like:

[
 [1, normal(5,2)],
 [2, normal(6,2.5)],
 [3, normal(7,3)],
  ...
]

And plots this.

The second challenge is finding improved functions for organizing this sort of thing. In theory, we could have a special function type that knows it's supposed to aggregate/memoize results, though this would probably be work.

One functional way of doing this might be something like,

memo fn(x) = x * normal(5,2)

... but this would be tricky, if we want to reset the memoization for a few different full runs.

[berekuk]

Thoughts:

1. This might be a common enough scenario that it makes sense to add a specialized simulate(steps, state, state => nextState) function to stdlib. But without your example I won't guess that it needs to return an array and not just a final state. Maybe we could have several variations of it (return array or a final state? allow access to previous states? stop based not on fixed steps count but on a condition?); having solid primitives for simulating processes seems important.

2. Arrays of pairs, or functions on discrete domains?

[OAGr]

Just thinking - memoize could help a lot here, maybe with a rec flag as well for recursive calls.
#1606