Exchange rates and exchange-rate pegs

Table of contents

Exchange rates and exchange-rate pegs

G-Cubed determines exchange rates jointly with interest rates, prices, capital flows, and the rest of the model. Uncovered interest parity (UIP), augmented by explicit risk wedges, determines the expected change in the forward-looking real exchange rate. The complete simultaneous model and its terminal conditions determine the level and path consistent with saving, investment, and external balance. Relative price levels convert the real exchange rate used in economic decisions into a nominal exchange rate. The monetary-policy rule determines how the central bank changes its short-term nominal interest rate in response to inflation, output, and, where selected, the exchange rate.

This page explains that standard system and three exchange-rate regimes:

a floating exchange rate under the standard monetary-policy rule;
an exact fixed exchange rate imposed as a structural equation; and
an adjustable or managed peg implemented with exchange-rate feedback in the monetary-policy rule.

The examples use variable names and equation forms found in current G-Cubed models. The OIL region in 22U/200 illustrates a peg to the US dollar, while the Eurozone treatment in 6G/200 illustrates the use of Germany (DEU) as a non-US benchmark. The methods are general: replace the example regions with sets and benchmark regions from the model version being modified.

These examples use the logged SYM representation. Apply the same economic conditions in the syntax and units of every model form that the build maintains, such as linear, log, equivalent_log, or experimental_log. Compile the modified SYM source, rebuild calibrated artifacts, and solve the model afresh. Do not reuse a solved-model cache created from the old equations.

Exchange-rate variables and quotation

The principal variables are:

Variable	Meaning
`EXCH(r)`	Nominal exchange rate: US dollars per unit of region `r`’s currency
`EXCL(r)`	Lagged nominal exchange rate
`REXC(r)`	Forward-looking real exchange rate governed by UIP
`REXN(r)`	Real exchange rate used in economic decisions
`PRID(r)`	Price index for domestic output
`INTN(r)`	Short-term nominal policy interest rate
`INTF(r)`	Short-term risk-free real interest rate
`INTR(r)`	Short-term risk-adjusted real interest rate
`EXCR(r)`	Country risk premium relative to the USA in UIP
`RISR(r)`	Risk premium added to the risk-free real rate

Because EXCH is quoted as US dollars per unit of local currency, an increase in EXCH(r) is an appreciation of region r’s currency against the US dollar. A decrease is a depreciation. This quotation matters when choosing the sign of exchange-rate feedback in a monetary-policy rule.

The USA is the reference region, so the logged SYM equations set EXCH(USA) = 0. A build’s database or published output may store physical exchange-rate levels and separate coordinate anchors. Use the active build’s runtime conversion contract when translating between those values and the logged equations.

In a logged equation, a bilateral exchange rate between region r and a benchmark region B is represented by:

\[e_{r,t}-e_{B,t}.\]

Since both currencies are quoted against the US dollar, this difference is the log of units of B’s currency per unit of r’s currency. A fixed bilateral exchange rate therefore requires this difference to be constant.

Exchange-rate determination under a float

The core equations can be written as follows. Lower-case letters denote logged variables.

The nominal exchange rate is the real exchange rate adjusted for the two price levels:

\[e_{r,t}=q_{r,t}-p_{r,t}+p_{USA,t}.\]

In the SYM source this normally appears as:

EXCH(notUSA) = REXN(notUSA) - PRID(notUSA) + PRID(USA);

The forward-looking real exchange rate evolves according to the real form of UIP:

\[E_t q_{r,t+1} =q_{r,t}-r_{r,t}+r_{USA,t}+x_{r,t},\]

where $x_{r,t}$ is EXCR(r). The corresponding SYM equation is:

lead(REXC) = REXC - INTR + INTR(USA) + EXCR;

Here $E_t$ denotes the next-period spot rate anticipated in the model solution; lead(...) is its SYM representation. This is uncovered, rather than covered, interest parity: the condition uses the projected future spot exchange rate and contains no exchange rate agreed today in a forward contract. Covered interest parity would relate the current spot rate, a contractual forward nominal exchange rate, and the two nominal interest rates. Solving the model under perfect foresight does not turn this equation into covered parity; lead(REXC) remains the projected next-period spot rate.

The real and nominal interest rates are connected by the Fisher relation and the risk wedge:

INTF = INTN - lead(PRID) + PRID;
INTR = INTF + RISR;

When REXN = REXC, combining these equations gives the nominal form of UIP:

\[E_t(e_{r,t+1}-e_{r,t}) =i_{USA,t}-i_{r,t} +EXCR_{r,t}+RISR_{USA,t}-RISR_{r,t}.\]

The quotation convention explains the signs. If the regional nominal interest rate rises relative to the US rate, expected EXCH(r) falls: the regional currency is expected to depreciate from a higher current value so that asset returns remain equal after allowing for risk wedges.

This is a simultaneous system. SYM equations are not executed as a sequence of assignments in which the equation for INTN must calculate INTN by itself. G-Cubed linearises the whole set of equations and solves the resulting matrix system. One equation can impose an exchange-rate condition while the UIP, Fisher, price, and benchmark-region equations jointly determine the interest rate consistent with it.

The build-200 SYM definitions examined for this guide set REXN = REXC and use REXC directly in the nominal exchange-rate identity. When applying the method to another build, first verify its active equation relating REXN and REXC.

What an exact peg implies for interest rates

For a currency fixed to the US dollar,

\[e_{r,t}=e_{r,t-1} \quad\Longrightarrow\quad E_t(e_{r,t+1}-e_{r,t})=0.\]

Nominal UIP then implies:

\[i_{r,t}=i_{USA,t} +EXCR_{r,t}+RISR_{USA,t}-RISR_{r,t}.\]

If the risk wedges are zero, the pegging region must adopt the US nominal interest rate. It no longer has an independent interest-rate instrument for stabilising its own inflation or output.

For a peg to another region B, subtract region B’s UIP condition from region r’s condition. A constant bilateral exchange rate implies:

\[i_{r,t}=i_{B,t} +(EXCR_{r,t}-EXCR_{B,t}) +(RISR_{B,t}-RISR_{r,t}).\]

Thus a country pegged to Germany inherits Germany’s monetary conditions, adjusted for the difference between their risk wedges. Germany remains the benchmark and must retain an equation that determines its own policy rate. The benchmark region must not also be placed in the set of regions whose rates are being determined by the peg.

These interest-rate formulas are economic consequences of the full equation system. Adding either formula to an otherwise unchanged model would duplicate conditions already contained in UIP, the Fisher relation, and the exchange-rate identity. Use one of the complete equation replacements below rather than adding an extra equation to an already square model.

Exact peg method 1: impose the peg in the `INTN` equation row

The smallest SYM modification keeps the existing exchange-rate and UIP equations and replaces the pegging regions’ monetary-policy rules with an exact exchange-rate constraint.

First define the sets. The names can be adapted to any model. Declare them in a source file that is processed before any equation that uses them:

set pegged_regions   = region_OIL;
set floating_regions = regions - pegged_regions;

Apply the ordinary monetary rule only to floating_regions. For a peg to the US dollar, give the pegging regions this equation:

pegged_regions: INTN = INTN - (EXCH - EXCL);

Although INTN appears on both sides, subtracting the right-hand side from the left-hand side gives:

\[EXCH(r)-EXCL(r)=0.\]

The INTN terms cancel deliberately. The equation row that ordinarily owns the regional monetary rule now owns the exchange-rate constraint. The other financial equations determine the INTN value compatible with that constraint. This is the compact pattern used for the OIL region in the 22U/200 USD-peg module.

For a group pegged to a non-US benchmark B, impose a constant bilateral exchange rate instead:

pegged_regions: INTN = INTN
    - ((EXCH - EXCL) - (EXCH(B) - EXCL(B)));

For example, with Germany as the benchmark, replace B by DEU. Cancellation of INTN leaves:

\[[e_{r,t}-e_{r,t-1}]-[e_{DEU,t}-e_{DEU,t-1}]=0.\]

Every pegged currency therefore moves one-for-one against the US dollar with the German currency, leaving its bilateral exchange rate against Germany unchanged.

This method looks unusual but has two practical advantages: it is a one-row replacement for each pegging region, and it preserves the established equation ownership used by the generated Python model. Its disadvantage is readability. A reader may initially mistake it for an interest-rate equation rather than an exchange-rate constraint.

Exact peg method 2: put the peg directly in the `EXCH` equation

The peg can instead be written in the equation for EXCH.

Create a non-US set whose ordinary exchange-rate identity excludes the pegged regions:

set floating_nonUSA = notUSA - pegged_regions;

floating_nonUSA: EXCH = REXN - PRID + PRID(USA);

For a direct peg to the US dollar, use:

pegged_regions: EXCH = EXCL;

For a peg to a non-US benchmark B, use:

pegged_regions: EXCH = EXCH(B) + EXCL - EXCL(B);

The latter says that the pegging currency’s movement against the US dollar must equal the benchmark currency’s movement against the US dollar. With B = DEU, it fixes each member’s bilateral rate against Germany at its previous-period value.

The displaced nominal-exchange-rate identity must then be placed in the INTN equation row in place of the standard monetary policy rule. For the pegged regions, regardless of the region they peg against, use:

pegged_regions: INTN = INTF + lead(PRID)
    + EXCH - REXN - PRID(USA);

An adjustable peg through the monetary-policy rule

A finite exchange-rate response in the monetary-policy rule produces a managed or adjustable peg. It does not impose the exchange rate as an exact identity. The standard rule has the form:

INTN = mrule_r*INTL
     + mrule_ex*exchange_rate_gap
     + mrule_1*inflation_gap
     + ...
     + mrule_8*output_growth_gap
     + ...
     + INTX;

For management against the US dollar, the standard exchange-rate gap is:

exchange_rate_gap = EXCH - EXCL - EXCX;

EXCX is the target change in the nominal exchange rate. Setting it to zero targets no appreciation or depreciation against the US dollar. A non-zero path defines a crawling target rather than a constant peg. Under the standard quotation, a positive EXCX targets appreciation and a negative EXCX targets depreciation.

For management against a non-US benchmark B, use the change in the bilateral rate:

exchange_rate_gap = (EXCH - EXCL)
                  - (EXCH(B) - EXCL(B))
                  - EXCX;

With B = DEU, a zero EXCX asks each managed currency to match the German currency’s movement against the US dollar. The bilateral rate can still move temporarily because the policy response is finite and because other terms in the monetary rule can be active.

A model can instead respond to a bilateral level gap:

exchange_rate_gap = EXCH - EXCH(B) - bilateral_level_target;

The 6G Eurozone rule uses this level form with Germany as B. A level target must be initialised in the same logged coordinate and units as the active SYM equations. It should not be confused with the standard use of EXCX as a target change. Giving the level offset its own clearly named exogenous variable is less ambiguous when designing a new model version.

Choosing the sign of `mrule_ex`

Under G-Cubed’s US-dollars-per-local-currency quotation, depreciation makes EXCH - EXCL negative. A stabilising central bank should raise its interest rate after depreciation. The required coefficient is therefore negative:

mrule_ex(r) < 0;

For example, a negative exchange-rate gap multiplied by a negative mrule_ex adds a positive amount to INTN. If a model version quotes its exchange rate in the opposite direction, this sign must also be reversed. Always check the variable declaration rather than copying a coefficient from another build.

Choosing the other monetary-rule parameters

The parameter combination defines how much exchange-rate adjustment is allowed:

Parameter choice	Policy interpretation
Finite negative `mrule_ex`; other target weights zero	The policy rate responds only to the exchange-rate gap. The rate can move temporarily, so this is a managed peg rather than an exact peg.
Larger absolute value of negative `mrule_ex`	Faster and stronger resistance to departures from the target; in the limit it approximates a hard peg but can make the numerical system stiff.
Non-zero `mrule_1`, `mrule_8`, or other `mrule_*` values	Hybrid regime. Inflation, output, or another target can justify temporary movement against the benchmark currency.
`mrule_r` close to one	Persistent policy-rate adjustment. With `mrule_r = 1`, the usual rule is expressed in first differences of the policy rate.
`0 < mrule_r < 1`	Less persistence in the policy rate. Check the build’s calibration residual or `INTX` path because the level toward which the rate adjusts is model-specific.
Non-zero `EXCX`	Crawling peg: the target bilateral exchange rate is allowed to appreciate or depreciate at the specified rate.
Non-zero `INTX`	Additional exogenous policy-rate adjustment outside the systematic rule.

To make the exchange-rate objective dominant, set the inflation, price-level, wage, output, and nominal-income response parameters (mrule_1 through mrule_15) to zero for the managed regions, except for any objectives that are intentionally retained. To give the central bank capacity to trade exchange-rate stability against domestic stabilisation, retain selected inflation or output weights and use a finite negative mrule_ex.

There is no model-independent value of mrule_ex that delivers a particular band around the benchmark. Its effect depends on the model’s units, policy-rate persistence, risk wedges, adjustment costs, and the other active targets. Choose it with sensitivity runs: start from a moderate magnitude, increase its absolute value, and compare the bilateral exchange-rate deviation, interest-rate volatility, inflation, output, and numerical stability.

The 6G Eurozone module provides a deliberately strong example. France, Italy, and the residual euro area use Germany as the nominal exchange-rate benchmark, have mrule_ex = -10000, and set the domestic inflation and output weights to zero. That calibration behaves like a near-hard common-currency condition. It is an example of a limiting parameterisation, not a generally recommended starting value for an adjustable peg.

A linear rule with finite mrule_ex provides smooth feedback; it does not create a literal intervention band. A regime that permits free movement inside a band and reacts only at its edges needs a piecewise equation or a separate intervention mechanism.

Selecting a method

Use a structural peg when the bilateral exchange rate must be exact in every projected period. Method 1 is the smallest source change and matches the existing 22U/200 pattern. Method 2 makes the peg equation immediately recognisable but requires the coordinated EXCH and INTN row rewrite.

Use finite mrule_ex feedback when the central bank resists exchange-rate movements but can also pursue inflation, output, or other objectives. This is a managed exchange-rate regime rather than an exact peg. A very large response can approximate an exact peg, but the structural equation is clearer and more reliable when exact equality is the intended economic assumption.

Whichever method is used:

Define the pegged set and benchmark region explicitly.
Exclude the benchmark from the pegged set.
Verify whether EXCH is quoted as US dollars per local currency.
Initialise EXCH and EXCL so the inherited bilateral parity is the one intended; the change-based equations preserve that starting parity.
Confirm the active build’s equation relating REXN and REXC.
Preserve one equation for every endogenous variable by replacing, rather than merely adding, equation rows.
Update every maintained SYM representation consistently.
Regenerate, recalibrate, solve, and compare the baseline and bilateral exchange-rate paths before using the modified build for experiments.

See monetary policy for the complete interpretation of the mrule_* targets and the nominal anchor.