The `shocks` block¶

The shocks; block assigns each exogenous variable (varexo) a deterministic, time-dependent path. Stochastic innovations have no place here — continuo solves a perfect-foresight problem, in which the realised exogenous values are the path the agents condition on.

Basic syntax¶

For each shock, repeat var <name>; followed by one or more path assignments. A bare path = …; is shorthand for path at t = 0 = … — “this path is the belief from t = 0 onward”:

shocks;
  var z;
  path = 1.1;                              // constant path: z(t) = 1.1
end;

The right-hand side of path is a symbolic expression in the reserved time t, the parameters, and the shock-shape helpers (below). It is evaluated at every grid node.

Time-dependent paths¶

Any expression in t is allowed. The simplest building block is if(condition, then, else), with the comparison and logical operators (<, <=, >, >=, ==, !=, &&, ||, !):

shocks;
  var z;
  path = if(t >= 5, 1.1, 1.0);                   // step at t = 5
end;

For common shapes, the helper functions below are clearer (and the parser sees the discontinuity locations explicitly).

Shock-shape helpers¶

The following helpers are available only inside ``shocks`` paths (they are rejected as a CodegenError in model equations):

`step(t, t0)`	0 before `t0`, 1 from `t0` on.
`pulse(t, t0, t1)`	1 on `[t0, t1)`, 0 elsewhere.
`ramp(t, t0, t1)`	0 then linear 0→1 over `[t0, t1]` then 1.
`bump(t, t0, t1)`	Smooth (C-infinity) bump on `(t0, t1)`, peak 1 at the centre.
`expdecay(t, t0, tau)`	0 before `t0`, then `exp(-(t-t0)/tau)` (value 1 at `t0`).
`smoothstep(t, t0, k)`	Logistic step at `t0` with steepness `k` (value 0.5 at `t0`).

They scale and shift like any expression:

shocks;
  var A;
  path = 1.0 + 0.05 * pulse(t, 8, 12);       // boom over [8, 12)

  var z;
  path = 1.0 + 0.05 * expdecay(t, 0, 3);     // exp-decaying shock
end;

Note

The shape helpers are lowered to the same CasADi expressions you would get by hand-writing them with if and arithmetic; their present role is documentary. A future release will use their explicit discontinuity arguments to auto-align the discretisation grid; until then, a discontinuity that falls between nodes is smeared by up to one dt.

Multi-revelation surprises¶

continuo supports beliefs that change over the simulation horizon, the continuous-time analogue of MIT shocks. Each path at t = <reveal_time> = <expression> declares that at the reveal time, agents adopt this expression as their belief about the entire future path of the shock.

shocks;
  var u;
  path at t=0  = if(t >= 7, 0.01, 0);    // initial belief
  path at t=4  = if(t >= 7, 0.03, 0);    // surprise at t = 4
  path at t=10 = if(t >= 7, 0.025, 0);   // another surprise at t = 10
end;

The reveal times partition [0, T] into segments; each segment is solved as a complete perfect-foresight problem under the belief active at its start, with the state carried continuously from the previous segment and the jumps re-optimising at the reveal. Only the realised slice [t_i, t_{i+1}) of each segment’s solve is kept; the agents’ counterfactual continuation beyond t_{i+1} is discarded.

Reveal times are sorted by the parser; duplicates on the same shock are rejected, and mixing the bare path = … sugar with an explicit path at t = 0 = … on the same shock is forbidden to keep the meaning unambiguous.

Anticipated vs unanticipated¶

A useful idiom — used in many of the shipped examples — is the contrast between

an anticipated future change, written as a single belief with the step inside it, so the whole horizon is one segment:
```
shocks;
  var e;
  path = 0.05 * step(t, 10);    // known from t=0, takes effect at t=10
end;
```

an unanticipated change at the same time, written as two beliefs:

shocks;
  var e;
  path at t=0  = 0;             // belief until the reveal
  path at t=10 = 0.05;          // learned only at t = 10
end;

The eventual realised paths are identical; the difference is what agents expect, which shows up in the jump variables (they react at t = 0 under anticipation, only at t = 10 under the surprise).