How are returns calculated when net asset value goes negative?
In “A tale of two returns” we highlighted the similarities and differences of log returns versus simple returns.
We create — in R — an example of net asset value at four times:
> nav1 <- c(1000, 900, 950, 1010) > nav1  1000 900 950 1010
Now we can compute the log (continuously compounded) returns:
> lret1 <- diff(log(nav1)) > lret1  -0.10536052 0.05406722 0.06124363
For log returns the sum of sub-period returns is the whole period return:
> sum(lret1)  0.009950331 > diff(log(nav1))  0.009950331
We can also compute the simple returns:
> sret1 <- nav1[-1]/nav1[-4] - 1 > sret1  -0.10000000 0.05555556 0.06315789
Combining sub-period returns is a little more involved for simple returns:
> prod(sret1 + 1) - 1  0.01 > nav1/nav1 - 1  0.01
The range of possible log returns is minus infinity to plus infinity. When the final price is zero, then the log return is minus infinity.
Minus infinity to infinity in log returns maps into minus one to plus infinity for simple returns. When the final price is zero, then the simple return is minus 1.
Negative net asset value
The view so far is that you can not lose more than you have.
Here is an example where the net asset value dips below zero:
> nav2 <- c(1000, 400, -200, 300) > nav2  1000 400 -200 300
We can try to compute log returns:
> lret2 <- diff(log(nav2)) Warning message: In log(nav2) : NaNs produced > lret2  -0.9162907 NaN NaN
NaN stands for Not-a-Number — that is, there was a calculation of indeterminate value.
The image we get from this is that negative net asset value is a black hole — once we cross that event horizon there is no coming back. That may or may not be true.
We can compute simple returns:
> sret2 <- nav2[-1]/nav2[-4] - 1 > sret2  -0.6 -1.5 -2.5
The second return, -1.5, is a reasonable answer — in that period we lost 1.5 times the value we started with. The last return is problematic though; conventional thinking says it should be positive — it is not.
Does time aggregation work for the simple returns?
> prod(sret2 + 1) - 1  -0.7 > nav2/nav2 - 1  -0.7
Yes. Even though we had a questionable value, something is going right.
So far in negative-NAV land we have log returns bombing out and simple returns seeming a little flaky.
The problem with log returns was that we were trying to take the logarithm of a negative number. That can be done if you allow complex numbers. Let’s try it:
> lret2c <- diff(log(as.complex(nav2))) > lret2c  -0.9162907+0.000000i -0.6931472+3.141593i  0.4054651-3.141593i
Now we get something that looks weird but seems promising:
> sum(lret2c)  -1.203973+0i > diff(log(nav2))  -1.203973
The imaginary part is keeping track of whether we are going from positive to negative, negative to positive, or neither.
Here are more examples:
> nav3 <- c(1000, -200, -250, -100, 300) > lret3c <- diff(log(as.complex(nav3))) > lret3c  -1.6094379+3.141593i 0.2231436+0.000000i  -0.9162907+0.000000i 1.0986123-3.141593i > nav4 <- c(1000, -200, -250, -400, 300) > lret4c <- diff(log(as.complex(nav4))) > lret4c  -1.6094379+3.141593i 0.2231436+0.000000i  0.4700036+0.000000i -0.2876821-3.141593i
The sign of the real part of the log returns is determined by the relative size of the absolute values of the valuations.
There is a formula for switching from log returns to simple returns. What happens when we do this with our complex-valued log returns?
> sret2c <- exp(lret2c) - 1 > sret3c <- exp(lret3c) - 1 > sret4c <- exp(lret4c) - 1 > sret2c  -0.6+0i -1.5+0i -2.5-0i > sret3c  -1.20+0i 0.25+0i -0.60+0i -4.00-0i > sret4c  -1.20+0i 0.25+0i 0.60+0i -1.75-0i > nav3[-1]/nav3[-5] - 1  -1.20 0.25 -0.60 -4.00 > nav4[-1]/nav4[-5] - 1  -1.20 0.25 0.60 -1.75 > prod(sret2c + 1) - 1  -0.7+0i > prod(sret3c + 1) - 1  -0.7-0i > prod(sret4c + 1) - 1  -0.7+0i
It works (modulo weird signs).
Exact zeros are problematic, however.
> nav5 <- c(1000, 200, 0, 300) > diff(log(as.complex(nav5)))  -1.609438+0i -Inf+0i Inf+0i > sum(diff(log(as.complex(nav5))))  NaN+0i > nav5[-1]/nav5[-4] - 1  -0.8 -1.0 Inf > prod(nav5[-1]/nav5[-4]) - 1  NaN
The complex-valued log returns may remind you of what some people consider the most beautiful equation in mathematics:
eiπ + 1 = 0
known as Euler’s identity.
It’s better to keep your NAV positive.
A more general way of computing simple returns (one of many) is:
tail(nav1, -1)/head(nav1, -1) - 1
This form works not only on vectors but also on matrices where the rows correspond to times and the columns are assets (or portfolios).