transform_weights: Transform weights

Description Usage Arguments Details Value Note References See Also Examples

Description

Useful transformations for the weights in a generalized mean.

Usage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Arguments

r, s

A number giving the order of the generalized mean. See details.

x

A strictly positive numeric vector.

w

A strictly positive numeric vector of weights, the same length as x. The default is to equally weight each element of x.

Details

Both x and w should be strictly positive. This is not enforced, but the results may not make sense in cases where the generalized mean and generalized logarithmic mean are not defined.

Transmute weights The function weights_transmute() returns a function to compute a vector of weights v(x, w) such that

mean_generalized(r)(x, w) == mean_generalized(s)(x, v(x, w)).

These weights are calculated as

v(x, w) = w * mean_extended(r, s)(x, mean_generalized(r)(x, w))^(r - s).

This generalizes the result for turning a geometric mean into an arithmetic mean (and vice versa) in section 4.2 of Balk (2008), although this is usually the most important case.

Contributions The function contributions() is a simple wrapper for weights_transmute(r, 1)() to calculate (additive) quote contributions for a price index. It returns a function to compute a vector k(x, w) such that

mean_generalized(r)(x, w) - 1 == sum(k(x, w)).

That is, k(x, w) gives the additive contribution for each element of x in an r-generalized mean. The contributions_arithmetic(), contributions_geometric() and contributions_harmonic() functions cover the most important cases. This generalizes the approach for calculating quote contributions in section 4.2 of Balk (2008).

Factor weights The function weights_factor() returns a function to compute weights u(x, w) such that

mean_generalized(r)(x * y, w) == mean_generalized(r)(x, w) * mean_generalized(r)(y, u(x, w)).

These weights are calculated as u(x, w) = w * x^r.

This generalizes the result in section C.5 of Chapter 9 of the PPI Manual for chaining the Young index, and gives a way to chain generalized price indexes over time. Factoring weights with r = 1 sometimes gets called price-updating weights; weights_update() simply calls weights_factor(1)().

Scale weights The function weights_scale() scales a vector of weights so they sum to 1 by calling x / sum(x, na.rm = TRUE).

Value

weights_transmute(), contributions(), and weights_factor() return a function:

function(x, w = rep(1, length(x)).

contributions_arithmetic(), contributions_geometric(), contributions_harmonic(), weights_update(), and weights_scale() return a numeric vector the same length as x.

Note

Transmuting, factoring, and scaling weights will return a value that is the same length as x, so any NAs in x or w will return NA. Unless all values are NA, however, the result for transmuting or factoring will still satisfy the above identities when na.rm = TRUE in mean_generalized(). Similarly, the result of scaling will sum to 1 when NAs are removed.

References

Balk, B. M. (2008). Price and Quantity Index Numbers. Cambridge University Press.

ILO, IMF, OECD, Eurostat, UN, and World Bank. (2004). Producer Price Index Manual: Theory and Practice. International Monetary Fund.

Sydsaeter, K., Strom, A., and Berck, P. (2005). Economists' Mathematical Manual (4th edition). Springer.

See Also

mean_generalized for the generalized mean.

mean_extended for the extended mean that underlies weights_transmute().

contributions_nested for an extension of contributions() to nested generalized means, like a Fisher index.

Examples

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
# Make some data

x <- 2:3
y <- 4:5
w <- runif(2)

# Calculate the geometric mean as an arithmetic mean and harmonic mean by 
# transmuting the weights

mean_geometric(x)
mean_arithmetic(x, weights_transmute(0, 1)(x))
mean_harmonic(x, weights_transmute(0, -1)(x))

# Works for nested means, too

w1 <- runif(2)
w2 <- runif(2)

mean_geometric(c(mean_arithmetic(x, w1), mean_harmonic(x, w2)))

v0 <- weights_transmute(0, 1)(c(mean_arithmetic(x, w1), mean_harmonic(x, w2)))
v0 <- weights_scale(v0)
v1 <- weights_scale(w1)
v2 <- weights_scale(weights_transmute(-1, 1)(x, w2))
mean_arithmetic(x, v0[1] * v1 + v0[2] * v2)

#--------------------

# Transmuted weights can be used to calculate quote contributions for, 
# e.g., a geometric price index

weights_scale(weights_transmute(0, 1)(x)) * (x - 1)
contributions_geometric(x) # the more convenient way

# Not the only way to calculate contributions

transmute2 <- function(x) {
  m <- mean_geometric(x)
  (m - 1) / log(m) * log(x) / (x - 1) / length(x)
}

transmute2(x) * (x - 1) # this isn't proportional to the method above
all.equal(sum(transmute2(x) * (x - 1)), mean_geometric(x) - 1)

# But these "transmuted" weights don't recover the geometric mean!
# Not a particularly good way to calculate contributions

isTRUE(all.equal(mean_arithmetic(x, transmute2(x)), mean_geometric(x)))

# There are infinitely many ways to calculate contributions, but the weights
# from weights_transmute(0, 1)() are the *unique* weights that recover the 
# geometric mean

perturb <- function(w, e) {
  w + c(e, -e) / (x - 1)
}

perturb(transmute2(x), 0.1) * (x - 1)
all.equal(sum(perturb(transmute2(x), 0.1) * (x - 1)),
          mean_geometric(x) - 1)
isTRUE(all.equal(mean_arithmetic(x, perturb(transmute2(x), 0.1)),
                 mean_geometric(x)))

#--------------------

# Any generalized index can be represented as a basket-style index
# by transmuting the weights, which is how some authors define a
# price index (e.g., Sydsaeter et al., 2005, p. 174)

p1 <- 2:6
p0 <- 1:5

qs <- weights_transmute(-1, 1)(p1 / p0) / p0
all.equal(mean_harmonic(p1 / p0), sum(p1 * qs) / sum(p0 * qs))

#--------------------

# Factor the harmonic mean by chaining the calculation

mean_harmonic(x * y, w)
mean_harmonic(x, w) * mean_harmonic(y, weights_factor(-1)(x, w))

# The common case of an arithmetic mean

mean_arithmetic(x * y, w)
mean_arithmetic(x, w) * mean_arithmetic(y, weights_update(x, w))

# In cases where x and y have the same order, Chebyshev's inequality implies
# that the chained calculation is too small

mean_arithmetic(x * y, w) > mean_arithmetic(x, w) * mean_arithmetic(y, w)

gpindex documentation built on Feb. 3, 2021, 1:06 a.m.