# maRketSim - Object manipulation functions
# The heirarchy:
# core functions calculate values from values
# market objects calculates from core functions
# bond object and functions calculate from market object
# portfolio calculates from bond object and market object
# account calculates from bond object and market objects held within a portfolio
# --- Object functions --- #
# Extract market interest rate from a market object
<- (mkt,mat=,dur=,f=.5) {
(taRifx)
# Error check inputs
((mat)&(dur)) ("Must specify either mat or dur.\n")
((mkt)!="market.bond"&(mkt)!="market") ("Market must be a market object, created using market().\n")
# Extract our bond market
((mkt)=="market.bond") {
mkt.b <- mkt
} {
mkt.b <- mkt$mkts[sapply(mkt$mkts,)=="market.bond"]]
}
# Return appropriate rates if they're easy to calculate
(!(mat) && mat <= 1/12) {
<- mkt.b$MMrate
(>=1) ("Your market interest rate should be expressed as a proportion (e.g. for a 5% yield, i=.05)\n")
()
}
(!(mkt.b$i)) {
(!(mat) && mat <=1/12) {
<- mkt.b$MMrate
} { ### This still doesn't catch maturities of less than 1/12yr that are specified by e.g. mat=NA,dur=.05, but it's not a big problem because that situation should never arise elsewhere in code
<- mkt.b$i
}
(>=1) ("Your market interest rate should be expressed as a proportion (e.g. for a 5% yield, i=.05)\n")
()
}
# Calculate intermediate values to use later
tol <- f*1.01 # tolerance to narrow in on our answer
# Calculate maturity from duration if no maturity is specified
((mat)&&(mkt.b$i)) {
### This will be difficult, since the market rate depends on the maturity, and the duration is calculated from the market rate and the maturity.
### We will need to interate towards the answer.
# example: dur=6.231105, mat=10,i=.1, mkt=market(yield.curve=quote(mat/100),MMrate=.02)
# example: dur=4.832336,mat=5,i=.0125,mkt=market(yield.curve=quote(mat^2/10000+.01),MMrate=.02)
# example for iyc: mat=12,i=.18, dur=4.853306, mkt=market(yield.curve=quote(.3-mat/100),MMrate=.02)
# Determine if the yield curve is inverted
mat <- 2 # Short-term
st <- (mkt.b$yield.curve)
mat <- 20 # Long-term
lt <- (mkt.b$yield.curve)
(st>lt) iyc <- -1 ###Do we not need a IYC converter at all?
(lt>st) iyc <- 1
(st==lt) ("If you want a flat yield curve, specify i instead of yield.curve when you make your market.\n")
# Initialize
<- (mkt.b$MMrate*4)
err <- (f)
mats <- ((dur=dur,i=last(),f=f))
n <- (mats)
# Loop
while () {
mat <- last(mats)
<- (,(mkt.b$yield.curve))
err <- (err,((mat=mat,i=last()) - dur) * iyc) # the error of our guess; multiply by the inverted yield curve 1/-1 variable to invert if inverted # *iyc
((last(err))==(err[length(err)-1])) { # keep heading in the same direction
mat <- mat - f*(last(err))
}
mats <- (mats,mat)
N <- (mats)
(N>6) {
(((mats((mats)-6):(mats)]))<tol)
(N>150) {
("Loop appears to have run away on us.\n")
("Likely cause is that you have selected a duration above the maximum duration.\n")
("Either select a lower duration or a higher interest rate.\n")
((=,mats=mats,err=err))
}
}
}
mat <- mats[which.min((err))-1] # the -1 is to shift it, since the structure is a bit messed up ;-)
}
# Return the yield curve rate for the given maturity
(!((mkt.b$yield.curve)) & (mkt.b$i)) {
<- (mkt.b$yield.curve)
(>=1) ("Your market interest rate should be expressed as a proportion (e.g. for a 5% yield, i=.05)")
()
} {
("Something went wrong.\n")
}
}
# Functions to return cash-flows from bonds and portfolio objects
<- (x,mkt,) {
("cashflow",x)
}
<- (x,mkt,) {
("There is no default cash flow function.\n")
}
<- (x,mkt,future=,f=x$f,) { ### Add in future=FALSE (past cash flows) for use with fv()
(future) {
t.elapsed <- mkt$ - x$t.issue
(t.elapsed<0) { ("Bond was issued after current market time!\n") }
effective.mat <- x$mat - t.elapsed
(effective.mat<0) { ("Bond expired. Specify future=FALSE if you want to examine past cashflows.\n") }
start.t <- (t.elapsed==0, x$t.issue+.5, (mkt$/f)*f) # return either the first coupon if we are at issue or the next coupon date
end.t <- (t.elapsed==0, x$mat, start.t+effective.mat)
}
{ # past
start.t <- x$t.issue
end.t <- (mkt$ < (x$mat+x$t.issue), mkt$, (x$mat+x$t.issue))
}
<- (start.t,end.t,x$f)
cashflows <- (x$cpn,())
cashflows[length(cashflows)] <- x$cpn + x$
res <- (=,=cashflows)
(res)
}
<- (x,mkt=x$orig.mkt,=,condense=,future=,) {
(future) {
x <- (object=x,mkt=mkt,)
}
{ # past
x <- (object=x,mkt=mkt,drop.future=,drop.expired=,)
}
l.cf <- (x$bonds,,mkt=mkt,future=future,)
u.cf <- (l.cf)
cf.df <- (
=u.cf[substr((u.cf),1,1)=="t"],
=u.cf[substr((u.cf),1,8)=="cashflow"]
)
() {
cf.df <- sort.data.frame(~+,cf.df)
}
res <- cf.df
(condense) {
condensed <- (cf.df$,cf.df$,)
res <- (=((condensed)), =condensed)
(res) <- ((res))
}
(res)
}
<- (x,mkt,future=,) {
res <- (=0,=0)
res <- res[0,]
("make cashflow.cash return actual values, using history.market as well as mkt$MM.frequency)")
(res)
}
<- (x,mkt,) {
cf.df <- (=,=)
cf.df <- cf.df[0,]
(n ((x$prts))) {
cf.df <- (cf.df,(x$prts[n]],mkt=mkt,future=))
}
cf.df <- (cf.df, >= x$t.issue & <= mkt$ )
(cf.df)
}
# Exclude bonds which have start t after current market time (e.g. which have not yet been purchased), and which have already matured
<- (object,mkt,drop.expired=,drop.future=,) {
t.issues <- (object$bonds,(x) {(x$t.issue)} )
mats <- (object$bonds,(x) {(x$mat)} )
expirations <- t.issues + mats
drop.bnds <- (,(t.issues))
(drop.expired) { drop.bnds <- (drop.bnds | (expirations<mkt$)) }
(drop.future) { drop.bnds <- (drop.bnds | (t.issues>mkt$)) }
select.bnds <- !drop.bnds
((select.bnds)!=(select.bnds)) {
("Keeping ",(select.bnds)," of ",(select.bnds)," bonds. Excluded bonds have",
(drop.expired,"expired ","")," ",(drop.expired&drop.future,"or ",""),(drop.future,"not yet been purchased",""),".\n",sep="")
}
object$bonds <- object$bonds[select.bnds]
(object)
}
# Functions to return the PV of different kinds of objects
<- (x,) {
("pv",x)
}
<- (x,) {
("Only bond, portfolio, cash, and account objects currently supported by pv().\n")
}
<- (x,mkt,) {
mat <- x$mat - (mkt$ - x$t.issue)
(i=x$i,mat=mat,=(mkt=mkt,mat=mat,f=x$f),=x$,f=x$f)$
}
<- (x,mkt=x$orig.mkt,) {
<- ((x$bonds,,mkt=mkt))
}
<- (x,) {
x$value
}
<- (x,mkt=x$orig.mkt,) {
<- ((x$prts,,mkt=mkt))
}
<- (x,="history.account",) { # returns a vector unlike most pv() functions
(=="history.account") {
f <- (y) (y,mkt=y$mkt.orig)
} (=="bond"|=="portfolio.bond") {
f <- (y) {
prts.bond <- y$prts[sapply(y$prts,(z) (z)[1])=="portfolio.bond"]
((prts.bond,))
}
} (=="cash") {
f <- (y) {
prts.cash <- y$prts[sapply(y$prts,(z) (z)[1])=="cash"]
((prts.cash,))
}
}
pvs <- (x,f)
(pvs)
}
# Functions to return the future value of various objects
<- (x, mkt, ) {
("fv",x)
}
<- (x, mkt, ) {
("Object type not yet supported.")
}
<- (x,mkt,) { ### update to use a market.history object instead
((mkt)=="market") {
t.elapsed <- mkt$ - x$t.issue
<- (P=x$value,i=mkt$MMrate,t.elapsed=t.elapsed,compound=x$compound)
}
}
<- (x,mkt,compound="continuous",) {
<- (x,mkt)
cflow <- (x,mkt)
t.elapseds <- mkt$ - cflow$
cpn <- cflow$
fv.cpn <- (,P=cflow$,t.elapsed=t.elapseds,MoreArgs=(i=mkt$MMrate,compound=compound))
res <- (price=,=fv.cpn)
res
}
# Functions to return the duration of a bond or portfolio object
<- (x,="modified",) {
("duration",x)
}
<- (x,="modified",mkt,) {
("There is no default duration function.\n")
}
<- (x,="modified",mkt,) { ### should this call summary.bond() instead so that it properly handles dates in between coupon payments?
t.elapsed <- mkt$ - x$t.issue
effective.mat <- x$mat - t.elapsed
<- (mkt=mkt,mat=effective.mat,f=x$f)
((mat=effective.mat,i=x$i,=,f=x$f,=))
}
<- (x,="modified",mkt,) {
(0) # This is a strong assumption (that cash is treated as 0 duration
}
<- (x,="modified",mkt,) {
# Error check inputs
(!="modified"&!="Macaulay") ("Must specify modified or Macaulay for record type.\n")
# Duration as weighted average of bond durations
pvs <- (x$bonds,,mkt=mkt)
pv.total <- (x,mkt=mkt)
durs <- (x$bonds,,mkt=mkt,=)
(((durs*pvs)/pv.total))
}
<- (x,="modified",mkt,) { # This will be mainly called by duration.summary.account, since usually we don't think of accounts as needing market arguments
# Error check inputs
(!="modified"&!="Macaulay") ("Must specify modified or Macaulay for record type.\n")
# Duration as weighted average of bond durations
pvs <- (x$prts,,mkt=mkt)
pv.total <- (x,mkt=mkt)
durs <- (x$prts,,mkt=mkt,=)
(((durs*pvs)/pv.total))
}
<- (x,="modified",) { # returns a vector, unlike most duration() functions
durs <- (x,(y) (y,mkt=y$mkt.orig,=))
(durs)
}
<- (x,="modified",) {
(!("history.account" %in% (x))) {
("Must set return.history.account=TRUE when running summary.account if you want a duration history\n")
}
((x$))
}
# Functions to restructure objects into data.frames
<- (x,) {
res <- (i=x$i,mat=x$mat,=x$,f=x$f,cpn=x$cpn,t.issue=x$t.issue)
res
}
<- (x,) {
res <- (i=,mat=,=,f=,cpn=,t.issue=)
ll <- (x$bonds,)
(z ((ll))) {
res <- (res,ll[z]])
}
res <- res-1,] # drop off our NAs
res
}
<- (x,) {
# t, pv, n.bonds, pv.bonds, pv.cash, dur
<- (x)
<- (x)
pv.bonds <- (x,="bond")
<- (x,="cash")
dur <- (x)
n.prt.bond <- (x,="portfolio.bond")
n.bonds <- (x,="bond")
((=,=,pv.bonds=pv.bonds,=,dur=dur,n.bonds=n.bonds,n.prt.bond=n.prt.bond,))
}
# Function to return the proportion of the portfolio in each asset class
<- (x,) {
("aa")
}
<- (x,) {
("No default method for asset allocation function yet.\n")
}
<- (x,=,force.cash=,) {
aa.vec <- ((x$prts,)) / (x)
(aa.vec) <- (((x$prts,),last))
# If force.cash, then we must have a cash category, even if it's 0%
(force.cash) {
(((aa.vec)!="cash")) {
aa.vec <- (aa.vec,0)
()[length()] <- "cash"
}
}
# Sort if specified
() { aa.vec <- aa.vec[order((aa.vec))] }
(aa.vec)
}
# Function to return the issue time of bonds
<- (x,) {
("issueTime")
}
<- (x,) {
("No default method for issueTime function.\n")
}
<- (x,) {
(x$t.issue)
}
<- (x,) {
(((x$bonds,)))
}
# Function to return the maturity time of bonds
<- (x,) {
("matTime")
}
<- (x,) {
("No default method for matTime function yet.\n")
}
<- (x,) {
( x$mat + (x) )
}
<- (x,) {
(((x$bonds,)))
}
# Function to return the current time of objects. Use carefully!
<- (x,) {
("mktTime")
}
<- (x,) {
("No default method for market time function\n")
}
<- (x,) {
(x$)
}
<- (x,) {
(x$t.issue)
}
<- (x,) {
((x,))
}
# Functions to return the number of objects of different types in a history.account object
<- (x,) { # this is equivalent to length() but length is a primitive and cannot be extended
("count")
}
<- (x,="history.account",) {
(=="history.account" | =="account") { # default behavior for length()
res <- ((x,="list"))
} { # Return vector counts (each element is a particular time period) of the requested object type
(=="portfolio") {
f <- (y) {(y$prts)}
} (=="portfolio.bond") {
f <- (y) {
((y$prts,(z) (z)[1])=="portfolio.bond")
}
} (=="cash") {
f <- (y) {
((y$prts,(z) (z)[1])=="cash")
}
} (=="bond") {
f <- (y) {
bond.prts <- (y$prts,(z) (z)[1])=="portfolio.bond"
((y$prts[bond.prts],(z) (z$bonds)))
}
}
res <- (x,f)
}
(res)
}
# - History.market handy functions - #
# Function to return the market object at a given time from a history.market object
# If no time point exists, interpolate by grabbing the previous market and returning a market object with those characteristics but the current time
<- (hist.mkt,,) {
<- ((hist.mkt,(x) x$))
sel.mkt <- ((hist.mkt))[t==]
((sel.mkt)!=1) { # If there's no exact match, interpolate
sel.mkt <- last(((hist.mkt))[ts<])
mkt <- hist.mkt[sel.mkt]]
mkt$ <-
} {
mkt <- hist.mkt[sel.mkt]]
}
(mkt)
}
# Interpolate between points on a yield curve and return a maturity. Used for the quoted yield.curve statements
# constant.max.mat=TRUE if you want it to return interest rates equal to the maximum maturity available if a mat is requested which exceeds the max maturity
<- (mat,,constant.max.mat=,) {
(($mat)!="numeric" | ($i)!="numeric") { ("Data.frame not formatted properly in call to connectTheDots\n") }
<- (,!($i))
<- sort.data.frame(~mat,)
(mat %in% $mat) {
i.ret <- $i[mat==$mat]
} {
l.mat <- last($mat[df$mat < mat])
((l.mat)) { ("Requested maturity ",mat," is lower than lowest value in data.frame ",first($mat),"\n") }
l.i <- $i[df$mat==l.mat]
u.mat <- first($mat[df$mat > mat])
((u.mat) & constant.max.mat== ) {
("Requested maturity ",mat," is higher than highest value in data.frame ",last($mat),"\n")
} ((u.mat) & constant.max.mat==) {
i.ret <- last($i)+.000000001*(mat-last($mat)) # Add in a tiny tiny fraction to help optimization functions find the right direction
} {
u.i <- $i[df$mat==u.mat]
# Interpolate
m <- (u.i-l.i)/(u.mat-l.mat)
i.ret <- m*(mat - u.mat) + u.i # point-slope form: y – y1 = m(x – x1)
}
}
((i.ret)) { ("NA's produced by connectTheDots\n") }
(i.ret)
}
# Function to take a data.frame of columns (i,mat,t) and turn it into a market.history with yield curves
<- (,drop.if.no.MMrate=,MM.mat=1/12,) {
mkts <- ()
<- ((($)))
(tm ) {
(tm,"\n")
df.t <- (,==tm)
( (df.t$mat<=MM.mat) | drop.if.no.MMrate== ) { # exclude those without a money market rate (1 month maturity)
mat.vars <- ('m1','m2','m3','m4','m5','m6','m7','m8','m9','m10','m11','m12','m13','m14','m15')
i.vars <- ('i1','i2','i3','i4','i5','i6','i7','i8','i9','i10','i11','i12','i13','i14','i15')
# Construct the list of interest rates and maturities to substitute in
yc.list <- ()
(n ((i.vars))) {
yc.list[length(yc.list)+1]] <- df.t$i[n]
(yc.list)[length(yc.list)] <- i.vars[n]
}
(n ((mat.vars))) {
yc.list[length(yc.list)+1]] <- df.t$mat[n]
(yc.list)[length(yc.list)] <- mat.vars[n]
}
# Construct our market
mkts[length(mkts)+1]] <- ((
yield.curve=(
(mat,(mat=(m1,m2,m3,m4,m5,m6,m7,m8,m9,m10,m11,m12,m13,m14,m15),i=(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15)))
,yc.list)
),=tm
)
}
}
hm <- (mkts)
(hm)
}
