# выделение данных за период в переменную

dta.m=pif.return[i:(i+(period-1)),]

# массив с весами оценок фондов

diff.best=c()

for(j in 1:ncol(dta.m)){

# данные по каждому фонду записаны в столбец

pif=dta.m[,j]

diff.best[j]=NA

# проверка на то, что количество данных по фонду

# соответсвует длине периода

if(length(na.trim(pif))==period){

# вычисление пересечения дат с Индексом МосБиржи

time=intersect(index(pif),index(moex))

# вычисление разности между фондом и индексом

diff.index=abs(Return.excess(pif,moex[as.Date(time)]))

# вычисление показателя для сравнения с другими фондами

diff.best[j]=mean(diff.index)*sd(diff.index)

}

}

# проверка, если все данные пустые

if(length(diff.best[is.na(diff.best)])==length(diff.best)) next

# заполнение названия фондов к их оценке

names(diff.best)=colnames(dta.m)

# остаются только те фонды, по которым сформирована оценка

diff.best=diff.best[!is.na(diff.best)]

#pif.best.name=names(diff.best)[which(diff.best==min(diff.best,na.rm = TRUE))]

#pif.act[tail(index(pif),n=1),pif.best.name]=TRUE

# запись в общую таблицу оценок фондов

pif.act[tail(index(pif),n=1),names(sort(diff.best))]=c(1:length(diff.best))

}

# создание копии таблицы

pif.act.copy=pif.act

# период для инвестиций

period=12

# стирание данных

pif.act[]=NA

# индикатор для начала

# вычисления фонда в который

# нужно инвестировать

j=11

for(i in 1:(nrow(pif.act.copy)-(period-1))){

# выделение данных за период в переменную

dta.m=pif.act.copy[i:(i+(period-1)),]

# проверка, достаточно ли данных в периоде

if(sum(dta.m[1,],na.rm = TRUE)>0){

# увеличение периода на 1 месяц

j=j+1

# если количество месяцев кратно периоду

# то нужно вычислять новый фонд для инвестиций

# на следующий период

if(j%%period==0){

# вычисляется сумма по каждому фонду

# затем данные записываются в массив

best=names(sort(colSums(dta.m)))[1]

# вычисление месяца начала инвестиций

k=i+period

# вычисление конечного месяца инвестиции

k1=ifelse((k+(period-1))>nrow(pif.act.copy),nrow(pif.act.copy),(k+(period-1)))

# запись в таблицу информации о том,

# в какой фонд будут сделаны инвестции

pif.act[index(pif.act.copy[k:k1,]),best[1]]=1

}

}

}

portfel.equity=function(prices, action, bank, fee, log = ""){

# индикатор, нухно ли вести логи

diag = FALSE

if(log!="") diag=TRUE

# значение комиссии на покупку

fee.buy=fee[1]

# значение комиссии на продажу

fee.sell=fee[2]

# запись текущей даты в логи

if(diag) write(as.character(Sys.time()),log,,FALSE)

# портфель, как массив активов

portfel=c()

# история изменения стоимости портфеля

portfel.history=action[,1]

portfel.history[]=NA

for(i in 1:nrow(action)){

# запись даты

if(diag) write(paste0("------------------------------",index(action)[i],"------------------------------"),log,,TRUE)

# если был сплит активов

n.act=action[i,names(portfel)]

if(length(n.act)>0) n.act=n.act[1,!is.na(n.act)]

if(length(n.act)>0) n.act=n.act[1,n.act>1]

if(length(n.act)>0) portfel[colnames(n.act)]=portfel[colnames(n.act)]*n.act

# если нет цен по всем активам в портфеле

pr=prices[i,names(portfel)]

if(length(pr)>0) pr=pr[1,!is.na(pr)]

if(length(pr)!=length(portfel)){

portfel.history[i]=equity

if(diag) write(paste0("По данным активам торги остановлены: ",paste(setdiff(names(portfel),colnames(pr)),collapse = " ")),log,,TRUE)

next

}

# стоимость портфеля

equity=sum(as.numeric(prices[i,names(portfel)]*portfel))+bank

# запись диагностической информации

if(diag) write(paste("Стоимость портфеля:",equity),log,,TRUE)

if(diag) write(paste("Банк:",bank),log,,TRUE)

if(diag) write(paste("Портфель:",paste(paste0(names(portfel),":"),portfel,collapse=", ")),log,,TRUE)

if(diag) write(paste("Количество:",length(portfel)),log,,TRUE)

# новый список активов для портфеля

buy=colnames(action)[which(!is.na(action[i,]))]

# запись стоиости портфеля в историю изменений

portfel.history[i]=equity

# если активы в портфеле такие же, в которые нужно инвестировать

if(length(setdiff(buy,names(portfel)))==0) next

if(diag) write(paste("Новый портфель:",paste(buy,collapse = " ")),log,,TRUE)

if(diag) write(paste("Количество:",length(buy)),log,,TRUE)

# если портфель пустой и покупать ничего не надо

if(length(portfel)==0 & length(buy)==0) next

# вес одной части в портфеле

part=0

# если покупать ничего не надо

if(length(buy)==0){

# будет ребалансировка

if (length(portfel)!=0) part=1/length(portfel)

} else {

# часть каждого актива (равновзвешенный)

part=1/length(buy)

}

# стоимость одной части портфеля

part.money=equity*part

if(diag) write(paste("Вес 1 части:",part),log,,TRUE)

# новые активы, которые нужно купить в портфель: разница между новым списком активов для портфеля и текущим портфелем

buy.new=setdiff(buy,names(portfel))

# акивы из портфеля, которые нужно продать: не входят в новой список активов для портфеля

sell.new=setdiff(names(portfel), buy)

#### сначала продаём активы из портфеля, чтобы пополнить количество денежных средств ####

if(length(sell.new)>0) {

if(diag) write(paste("##### Продажа ",paste(sell.new,collapse = " ")),log,,TRUE)

for(p in sell.new){

# текущая цены пифа

price=as.numeric(prices[i,p])

# если нет цены - переход к следующему активу

if(is.na(price)) next

# вычисление комиссии

fee=price * fee.sell

# количество данного актива в портфеле

n=as.numeric(portfel[p])

if(diag) write(paste("ПИФ:",p,"Цена:",price,"Кол-во:",n,"Итого:",n*price,"Комиссия:",n*fee),log,,TRUE)

# изменение цены с учётом комиссии

price=price - fee

# продажа и пополнение количества денежных средств

bank=bank + n*price

}

# исключение проданных пифов из портфеля

portfel=portfel[! names(portfel) %in% sell.new]

}

# созранение информации о стоимости портфеля

portfel.history[i]==sum(as.numeric(prices[i,names(portfel)]*portfel))+bank

# портфель стал пустым и покупать ничего не нужно

if(length(portfel)==0 & length(buy.new)==0) next

#### далее ребалансировка оставшихся пифов в портфеле (не покупка новых) ####

# цикл по оставшимся пифам в портфеле

#### ребалансировка на продажу ####

if(diag) write("##### Допродажа #####",log,,TRUE)

for(p in names(portfel)){

# текущая цены актива

price=as.numeric(prices[i,p])

# если нет цены - переход к следующему активу

if(is.na(price)) next

# количество пифа в портфеле

n=as.numeric(portfel[p])

# стоимость доли данного пифа

part.price=price*n

# величина части в портфеле

part.p=part.price/equity

# если стоимости доли актива больше новой стоимости одной части, то продажа избытка

if(part.p > part){

# разница для продажи

diff.m=part.price - part.money

# количество, которое будет продано (округление вверх)

n.new= ceiling(diff.m / price)

# если ничего не нужно продавать, то выход

if(n.new==0) next

# вычисление комиссии

fee=price*fee.sell

if(diag) write(paste("ПИФ:",p,"Цена:",price,"Кол-во:",n.new,"Итого:",n.new*price,"Комиссия",n.new*fee),log,,TRUE)

# изменение цены с учётом комиссии

price=price-fee

# вычитание проданного количества пифов

portfel[p]=portfel[p] - n.new

# увеличение банка

bank=bank + n.new*price

# если был продан весь актив

portfel=portfel[! portfel == 0]

}

}

#### ребалансировка на покупку ####

if(diag) write("##### Допокупка #####",log,,TRUE)

for(p in names(portfel)){

# текущая цены актива

price=as.numeric(prices[i,p])

# если нет цены - переход к следующему активу

if(is.na(price)) next

# количество актива в портфеле

n=as.numeric(portfel[p])

# стоимость актива в портфеле

part.price=price*n

# величина части в портфеле

part.p=part.price/equity

# если часть меньше, то нужно докупать

if(part.p < part){

# разница для покупки

diff.m=part.money - part.price

# вычисление комиссии

fee=price*fee.buy

# цена без комиссии

price.old=price

# цена с комиссией

price=price + fee

# количество, которое можно докупить

n.new=floor(diff.m / price)

# если ничего не надо докупать - переход к следующему активу

if(n.new==0) next

if(diag) write(paste("ПИФ:",p,"Цена:",price.old,"Кол-во:",n.new,"Итого:",n.new*price.old,"Комиссия:",n.new*fee),log,,TRUE)

# добавление купленного количества актива в портфель

portfel[p]=portfel[p] + n.new

# уменьшение свебодных денежных средств

bank=bank-n.new*price

}

}

#### покупка новых пифов ####

if(length(buy.new)>0) {

if(diag) write(paste("##### Покупка ",paste(buy.new,collapse = " ")),log,,TRUE)

# если портфель - это оди актив, то стоимость одной части

# это все доступные денежные средства

if(part==1) part.money=bank

for(p in buy.new){

# текущая цены актива

price=as.numeric(prices[i,p])

# если нет цены - переход к следующему активу

if(is.na(price)) next

# вычисление комиссии

fee=price*fee.buy

# цена без комиссии

price.old=price

# цена с комиссией

price=price+fee

# количество актива, которое можно купить

n=floor(part.money / price)

if(diag) write(paste("Бюджет:",part.money,"ПИФ:",p,"Цена:",price.old,"Кол-во:",n,"Итого:",n*price.old,"Комиссия:",n*fee),log,,TRUE)

# если ничего не купить, то выход

if(n==0) next

# добавление актива в портфель

portfel=append(portfel,n)

# уменьшение свободных денежных средств

bank=bank - n*price

# добавление названия актива в портфель

names(portfel)[length(portfel)]=p

}

}

#####

if(diag) write("##########",log,,TRUE)

# вычисление стоимости портфеля

equity=sum(as.numeric(prices[i,names(portfel)]*portfel))+bank

if(diag) write(paste("Стоимость портфеля:",equity),log,,TRUE)

if(diag) write(paste("Банк:",bank),log,,TRUE)

if(diag) write(paste("Портфель:",paste(paste0(names(portfel),":"),portfel,collapse=", ")),log,,TRUE)

if(diag) write(paste("Количество:",length(portfel)),log,,TRUE)

# сохранение информации о стоимости портфеля

portfel.history[i]=equity

}

# в качестве результата возвращается

# таблица данных о временной стоимости портфеля

return(portfel.history)

}

require(PerformanceAnalytics)

Sys.setlocale("LC_TIME", "English")

moex10=read.csv("~/MOEX10.csv",stringsAsFactors = FALSE)

moex10=xts(as.numeric(gsub(",", "", moex10[,2])),order.by = as.Date(moex10[,1], format = "%b %d, %Y"))

moex10=monthlyReturn(to.monthly(moex10, indexAt = 'lastof'))

boot.all = function(return, bench, rf, boot.n = 10, period = 24, l1 = 0.99, l2 = 0.5){

# библиотека для перемешивания значений массива

require(tseries)

# основная таблица t-статистик

boot=matrix(NA,nrow = ncol(return),ncol = (boot.n + 1))

# название строк соответствует названия фондов

row.names(boot)=colnames(return)

# цикл по каждому фонду

for(j in 1:ncol(return)){

# данные по одному фонду

pif=return[,j]

# удаление пустых значений

pif=pif[!is.na(pif)]

# если достаточное количество данных

if(length(na.trim(pif))>period){

# пересечение данных по фонду, бенчмарку и безрисковой ставке по времени

time=intersect(intersect(index(pif),index(rf)),index(bench))

# если достаточно общего количества данных

if(length(time)>period){

# избыточная доходность фонда

Er=Return.excess(pif[as.Date(time)],rf[as.Date(time)])

# избыточная доходность бенчмарка

Eb=Return.excess(bench[as.Date(time)],rf[as.Date(time)])

# если количество данных совпадает

if(length(Er)==length(Eb)){

# регрессия на реальных данных

capm=summary(lm(Er ~ Eb))

# альфа коэффициент

capm.alfa=capm$coefficients[1,1]

# t-статистика альфа коэффициента

capm.t=capm$coefficients[1,3]

# бета коэффициент

capm.beta=capm$coefficients[2,1]

# остатки, ошибки регрессии

capm.res=capm$residuals

# сохранение реального значения t-статистики

boot[j,1]=capm.t

# восстановление избыточной доходности

const = capm.beta * Eb

# бутстрап

# цикл регрессий по восстановленным данным

for(k in 1:boot.n){

# перемешивание остатков

res=xts(tsbootstrap(ts(capm.res)), order.by = index(capm.res))

# добавление остатков к восстановленным данных

Er.b = const + res

# регрессия на восстановленных данных

capm.b = summary(lm(Er.b ~ const))

# сохранение симулированной t-статистики

boot[j,(1+k)]=capm.b$coefficients[1,3]

}

}

}

}

}

# массив лучших симулированных коэффициентов

t.best={}

# цикл по столбцам бутстрапа

for (l in 2:boot.n){

# отбор и добавление лучших коэффициентов из столбца

t.best=c(t.best,boot[which(boot[,l]>=quantile(na.omit(boot[,l]),c(l1)) & boot[,l]>0),l])

}

# массив лучших фондов

pif.best={}

# цикл по первому столбцу таблицы

# с коэффициентами на реальных данных

for(l in 1:nrow(boot)){

# если есть значение коэффициента у фонда

if(!is.na(boot[l,1])){

# если значение коэффицента выше уровня квантили массива лучших коэффициентов

if(boot[l,1]>quantile(t.best,c(l2))){

# добавление значения коэффициента фонда в массив

pif.best=c(pif.best,boot[l,1])

# добавления названия фонда к коэффциенту

names(pif.best)[length(pif.best)]=row.names(boot)[l]

}

}

}

# сортировка массива лучших фондов

# по убыванию значений коэффициентов

pif.best=sort(pif.best, decreasing = TRUE)

# возврат в качестве результата

# массив лучших фондов

return(pif.best)

}

# бенчмарк портфель из индексных паевых фондов

benchmark.pif=portfel.equity(pif.price, pif.act, 10000, c(0.005, 0.015))

# доходность бенчмарка

benchmark.pif.return=pif.graph(benchmark.pif, moex)

# функция вычисления лучших фондов

best.pif=boot.all(return = pif.return, bench = benchmark.pif.return, rf = ru.1y, boot.n = 100, period = 24, l1 = 0.99, l2 = 0.5)

# результат

cat(paste(all[all[,3] %in% names(best.pif),1],round(best.pif,2)),sep = "\n")

# вызов функции с параметрами

benchmark.stock=portfel.equity(data.10, data.act, 10000, c(0.0001, 0.0001))

# месячная доходность бенчмарка

benchmark.stock.return=monthlyReturn(Cl(to.monthly(benchmark.stock, indexAt = 'lastof')))

# функция вычисления лучших фондов

best.stock=boot.all(return = pif.return, bench = benchmark.stock.return, rf = ru.1y, boot.n = 100, period = 24, l1 = 0.99, l2 = 0.5)

# результат

cat(paste(all[all[,3] %in% names(best.stock),1],round(best.stock,2)),sep = "\n")

# вызов функции

benchmark.future=future.benchmark()

# месячная доходность бенчмарка

benchmark.future.return=monthlyReturn(Cl(to.monthly(benchmark.future, indexAt = 'lastof')))

# функция вычисления лучших фондов

best.future=boot.all(return = pif.return, bench = benchmark.future.return, rf = ru.1y, boot.n = 100, period = 24, l1 = 0.99, l2 = 0.5)

# результат

cat(paste(all[all[,3] %in% names(best.future),1],round(best.future,2)),sep = "\n")

boot.history = function(return, bench, rf, boot.n = 10, period = 24, l1 = 0.99, l2 = 0.5){

# библиотека для перемешивания значений массива

require(tseries)

# основная таблица с результатами бутстрапа

# структура копируется с таблицы доходностей активов

boot.res=return

# очистка данных

boot.res[]=NA

# цикл с движущимся окном

for(i in 1:(nrow(return)-(period-1))){

# данные по доходности активов за период

dta.m=return[i:(i+(period-1)),]

# таблица t-статистик

boot=matrix(NA,nrow = ncol(dta.m),ncol = (boot.n + 1))

# название строк соответствует названию активов

row.names(boot)=colnames(dta.m)

# цикл по каждому активу

for(j in 1:ncol(dta.m)){

# данные по активу за период

pif=dta.m[,j]

# если достаточное кодичество данных

if(length(na.trim(pif))==period){

# пересечение данных по фонду, бенчмарку и безрисковой ставке по времени time=intersect(intersect(index(pif),index(rf)),index(bench))

# если достаточно общего количества данных

if(length(time)==period){

# избыточная доходность фонда

Er=Return.excess(pif[as.Date(time)],rf[as.Date(time)])

# избыточная доходность бенчмарка

Eb=Return.excess(bench[as.Date(time)],rf[as.Date(time)])

# если количество данных совпадает

if(length(Er)==length(Eb)){

# регрессия на реальных данных

capm=summary(lm(Er ~ Eb))

# альфа коэффициент

capm.alfa=capm$coefficients[1,1]

# t-статистика альфа коэффициента

capm.t=capm$coefficients[1,3]

# бета коэффициент

capm.beta=capm$coefficients[2,1]

# остатки, ошибки регрессии

capm.res=capm$residuals

# сохранение реального значения t-статистики

boot[j,1]=capm.t

# восстановление избыточной доходности

const = capm.beta * Eb

# бутстрап

# цикл регрессий по восстановленным данным

for(k in 1:boot.n){

# перемешивание остатков

res=xts(tsbootstrap(ts(capm.res)), order.by = index(capm.res))

# добавление остатков к восстановленным данных

Er.b = const + res

# регрессия на восстановленных данных

capm.b = summary(lm(Er.b ~ const))

# сохранение симулированной t-статистики

boot[j,(1+k)]=capm.b$coefficients[1,3]

}

}

}

}

}

# массив лучших симулированных коэффициентов

t.best={}

# цикл по столбцам бутстрапа

for (l in 2:boot.n){

# отбор и добавление лучших коэффициентов из столбца

t.best=c(t.best,boot[which(boot[,l]>=quantile(na.omit(boot[,l]),c(l1)) & boot[,l]>0),l])

}

# массив лучших фондов

pif.best={}

# цикл по первому столбцу таблицы

# с коэффициентами на реальных данных

for(l in 1:nrow(boot)){

# если есть значение коэффициента у фонда

if(!is.na(boot[l,1])){

# если значение коэффицента выше уровня квантили массива лучших коэффициентов

if(boot[l,1]>quantile(t.best,c(l2))){

# добавление значения коэффициента фонда в массив

pif.best=c(pif.best,boot[l,1])

# добавления названия фонда к коэффциенту

names(pif.best)[length(pif.best)]=row.names(boot)[l]

}

}

}

# сортировка массива лучших фондов

# по убыванию значений коэффициентов

pif.best=sort(pif.best, decreasing = TRUE)

# лучшие активы за данный период отмечаются в общей таблице

boot.res[tail(index(dta.m),n=1),names(pif.best)]=c(1:length(pif.best))

}

# массив сумм по стоблцам

sums=colSums(boot.res,na.rm = TRUE)

# удаляюся те фонды

# которые ни разу не были отмечены

sums=sums[sums>0]

# удаление данных фондов из таблицы

boot.res=boot.res[,names(sums)]

# возвращение таблицы в качестве результата функции

return(boot.res)

}

boot.act=function(boot.res, period = 4){

# создание копии таблицы

copy=boot.res

# стирание данных

copy[]=NA

# индикатор для начала

# вычисления фонда в который

# нужно инвестировать

j=period - 1

for(i in 1:(nrow(boot.res)-(period-1))){

# выделение данных за период в переменную

dta.m=boot.res[i:(i+(period-1)),]

# проверка, достаточно ли данных в периоде

if(length(sort(colSums(dta.m)))>0){

# увеличение периода на 1 месяц

j=j+1

# если количество месяцев кратно периоду

# то нужно вычислять новый фонд для инвестиций

# на следующий период

if(j%%period==0){

# вычисляется сумма по каждому фонду

# затем данные записываются в массив

best=names(sort(colSums(dta.m)))

n=as.numeric(floor(quantile(c(0:length(best)),.25)))

# вычисление месяца начала инвестиций

#k=i+period

k=ifelse((i+period)>=nrow(copy),nrow(copy),(i+period))

# вычисление конечного месяца инвестиции

k1=ifelse((k+(period-1))>=nrow(copy),nrow(copy),(k+(period-1)))

# запись в таблицу информации о том,

# в какой фонд будут сделаны инвестции

copy[index(copy[k:k1,]),best[1]]=1

}

}

}

# массив сумм по стоблцам

sums=colSums(copy,na.rm = TRUE)

# удаляюся те фонды

# которые ни разу не были отмечены

sums=sums[sums>0]

# удаление данных фондов из таблицы

copy=copy[,names(sums)]

# возвращение таблицы в качестве результата функции

return(copy)

}

for(i in 1:nrow(copy)){

if(sum(copy[i,],na.rm = TRUE)>0){

break

}

}

# функция вычисления лучших фондов по периодам

best.pif.boot=boot.history(return = pif.return, bench = benchmark.pif.return, rf = ru.1y, boot.n = 10, period = 24, l1 = 0.99, l2 = 0.5)

# функция для установки индикаторов

best.pif.act=boot.act(best.pif.boot,4)

# построение портфеля

portfel=portfel.equity(pif.price, best.pif.act, 10000000, c(0.005, 0.015))

# доходность портфеля

portfel.return=pif.graph(portfel,moex)

pif.graph = function(portfel, bench, file=""){

i=index(portfel)[which(as.numeric(portfel)!=as.numeric(portfel[1]))[1]]

# пересечение дат с индексом

dt=intersect(index(portfel),index(bench))

i=which(as.Date(dt)==i)

dt=dt[i:length(dt)]

test=cbind(bench[as.Date(dt)],Return.calculate(portfel[as.Date(dt)]))

# наименование столбцов

colnames(test)=c("MOEX","Portfel")

# построение графика

if(file!=""){

png(file,width = 1000,height = 1155, units = "px", pointsize = 20)

charts.PerformanceSummary(test)

dev.off()

} else {

charts.PerformanceSummary(test)

}

# регрессия

print(summary(lm(test[,2]~test[,1])))

portfel.return=Return.calculate(portfel[as.Date(dt)])

portfel.return[1]=0

return(portfel.return)

}

future.benchmark = function(){

# чтение данных из файла

future=read.csv("F:/vkr/MX.csv", stringsAsFactors = F)

# наименование фьючерсов

future.name=unique(future[,2])

# таблица со значениями ГО по фьючерсам

future.data=as.data.frame(matrix(NA,nrow = nrow(future), ncol = length(future.name)))

# название строк

row.names(future.data)=future[,1]

# название столбцов

colnames(future.data)=future.name

# преобразование во временной формат данных

future.data=as.xts(future.data, order.by = as.Date(row.names(future.data), "%d.%m.%Y"))

# создание новых таблиц копированием

future.price=future.price.estim=future.action=future.data

# заполнение данных по каждому фьючерсу

for(name in future.name){

# временная переменная

x=future[future[,2]==name,]

# преобразование формата даты

date=as.Date(x[,1], "%d.%m.%Y")

# заполнение значений ГО

future.data[date,name]=x[,16]

# заполнение актуальности фьючерса

future.action[date,name]=1

# заполнение значений средней взвешенной цены

future.price[date,name]=x[,3]

# заполнение значений цены расчета

future.price.estim[date,name]=x[,4]

# удаление временных переменных

rm(x,date)

}

# величина свободных денежных средств

portfel.bank=1000000

# наименование текущего фьючерса в портфеле

portfel.name=""

# история изменения стоимости портфеля

portfel.history=future.data[,1]

# стирание данных

portfel.history[]=NA

for(i in 1:nrow(future.data)){

# фьючерс в который нужно инвестировать на данной итерации

buy=colnames(future.action)[which(!is.na(future.action[i,]))]

# если фьючерс отличается от фьючерса в портфеле

# и портфель не пустой то происходит освобождение ГО

if(buy!=portfel.name & portfel.name!=""){

# ГО возвращается в свободные сердства

portfel.bank=portfel.bank + portfel.warranty

# удаление переменных

rm(portfel.warranty,portfel.count,portfel.price)

}

# если новый фьючерс и фьючерс в портфеле не совпадают

# то нужно инвестировать в данный фьючерс

# ГО было освобождено на предыдущем шаге

if(buy!=portfel.name){

# текущая стоимость фьючерса - это ГО

price=as.numeric(future.data[i,buy])

# инвестиции без "плеча"

# цена количества фьючерсов покрывает весь банк

n=ceiling(portfel.bank / as.numeric(future.price[i,buy]))

# свободные денежные средства

# уменьшаются только на величину ГО

portfel.bank=portfel.bank - n * price

# сохранение количества

portfel.count=n

# сохранение наименования фьючерса

portfel.name=buy

# цена фьючерса для вычисления маржинального требования

portfel.price=as.numeric(future.price[i,buy])

# общий размер ГО

portfel.warranty=n * price

# удаление переменных

rm(price,cash,n)

}

# если в портфеле есть фьючерс

if(portfel.count > 0){

# актуальное значение ГО

warranty.price = as.numeric(future.data[i,portfel.name])

if(!is.na(warranty.price)){

# вычисление актульного ГО покрывающее портфель

warranty=warranty.price * portfel.count

# разница между зарезервированным и актуальным ГО

diff.warranty = portfel.warranty - warranty

# изменение величины свободных средств

portfel.bank = portfel.bank + diff.warranty

# зарезервированное ГО становится актуальным

portfel.warranty = warranty

}

# вычисление маржинального требования

if(portfel.price==as.numeric(future.price[i,portfel.name])){

# инвесировани было в данный день

margin=(as.numeric(future.price.estim[i,portfel.name]) - portfel.price) * portfel.count

} else {

# между двумя датами как ращница расчётных цен

margin=(as.numeric(future.price.estim[i,portfel.name]) - as.numeric(future.price.estim[(i-1),portfel.name])) * portfel.count

}

# если свободных средств и ГО не хватает

# для покрытия маржинального требования

if((portfel.bank + portfel.warranty) < margin){

# происходит margin call

print("Банк опустел")

break

}

# в конце каждого торгового дня свободные средства

# изменяются на величину маржинального требования

portfel.bank = portfel.bank + margin

# удаление переменных

rm(warranty,margin,diff.warranty,warranty.price)

}

portfel.history[i]=portfel.bank + portfel.warranty

}

return(portfel.history)

}

# получение наименования файлов

files=list.files("~/dat",full.names=TRUE)

# общая таблица с данными

data.equity=data.frame()

for(file in files){

# чтение одного файла

eq=read.csv(file,stringsAsFactors=FALSE)

# добавление данных в одну таблицу

data.equity=rbind(data.equity,eq)

}

tickers<-unique(data.equity[,1])

setwd("F:/vkr")

dir=getwd()

# информация о базе расчета Индекс ММВБ 10

mic.10<-read.csv(paste0(dir,"/10micexdata.csv"),header = FALSE,stringsAsFactors = FALSE)

# изменения наименования сокращенных названий акций

mic.10.replace=read.csv(paste0(dir,"/10micex.csv"),header = FALSE,stringsAsFactors = FALSE)

# замена наименования сокращенных названий акций в базе расчета

for(i in 1:nrow(mic.10.replace)){

mic.10[mic.10==mic.10.replace[i,1]]=mic.10.replace[i,2]

}

mic.ticker=c()

mic.ticker=unique(unlist(sapply(c(18:nrow(mic.10)),function(i){mic.ticker=append(mic.ticker,mic.10[i,3:12])})))

mic.ticker=mic.ticker[mic.ticker!=""]

date.all=c() # массив со всеми датами

for(i in 18:nrow(mic.10)){

# база расчета Индекса ММВБ 10 за определенный период

tickers=unlist(mic.10[i,3:length(mic.10[i,])])

# массив календарных дат для базы расчета

dates=seq.Date(as.Date(mic.10[i,1],"%d.%m.%Y"), as.Date(mic.10[i,2],"%d.%m.%Y"), by = "day")

date.t=c() # массив дат для текущей базы расчета

for(t in tickers){

# данные по одной акции из базы расчёта

y=data.equity[which(data.equity[,1]==t),]

# пересечение календарнх дат и торговых дней

date.inter=intersect(dates,as.Date(y[,2]))

# добавление пересечения дат в массив

date.t=append(date.t,date.inter)

}

# добавление уникальных дат в общий массив

date.all=append(date.all,unique(date.t))

}

# структурированная таблица с данными

data.10=xts(matrix(NA, nrow = length(date.all), ncol = length(mic.ticker),dimnames = list(date.all,mic.ticker)),order.by = as.Date(date.all))

for(t in colnames(data.10)){

# данные по одной акции из базы расчёта

y=data.equity[which(data.equity[,1]==t),]

# цены закрытия по данной акции

y=xts(Cl(y),order.by=as.Date(y[,2]))

# заполнение данных в таблице

data.10[index(y),t]=y[index(data.10)]

}

for(i in 18:nrow(mic.10)){

# база расчета Индекса ММВБ 10 за определенный период

tickers=unlist(mic.10[i,3:length(mic.10[i,])])

for(t in tickers){

if(t=="") next

# данные по одной акции из базы расчёта

y=data.equity[which(data.equity[,1]==t),]

# цены закрытия по данной акции

y=xts(Cl(y),order.by=as.Date(y[,2]))

# пересечение дат в таблице и торговых дат для акции

#date.inter=intersect(index(data.10),index(y))

# заполнение данных в таблице

data.10[index(y),t]=y

}

}

for(t in colnames(data.10)){

y=data.equity[which(data.equity[,1]==t),]

# цены закрытия по данной акции

y=xts(Cl(y),order.by=as.Date(y[,2]))

# заполнение данных в таблице

data.10[index(y),t]=y[index(data.10)]

}

for(i in 1:nrow(data.10)){

r=data.10[i,]

if(length(r[,!is.na(r)])<10) print(index(r))

}

# структурированная таблица с данными

data.act=xts(matrix(NA, nrow = length(date.all), ncol = length(mic.ticker),dimnames = list(date.all,mic.ticker)),order.by = as.Date(date.all))

for(i in 18:nrow(mic.10)){

# база расчёта индекса

tickers=unlist(mic.10[i,3:length(mic.10[i,])])

# удаление пустых значений

tickers=tickers[tickers!=""]

# период действия базы расчёта

dates=seq.Date(as.Date(mic.10[i,1],"%d.%m.%Y"), as.Date(mic.10[i,2],"%d.%m.%Y"), by = "day")

# заполнение индикаторов, о вхождении акций в портфель

data.act[dates,tickers]=TRUE

}

# сплит акций

data.act["2007-07-18","SBER"]=1000

data.act["2007-07-18","SBERP"]=20

# заполнение индикаторов

# чтобы акции не были исклчены из портфеля

data.act[c("2007-07-19","2007-07-20"),c("SBER","SBERP")]=TRUE

Размещено на Allbest.ru

...