【问题标题】:Create a results-matrix after using for-loops使用 for 循环后创建结果矩阵
【发布时间】:2013-06-25 11:35:28
【问题描述】:

我(作为 R 和编程的绝对初学者)必须为我的金融论文用 R 做一些分析:( 目的是用 GBM 模拟数据(股票价格)并运行结果 2 交易策略。在 GBM 中,我将不得不“玩”变量“r”和“sigma”(每个有 3 个不同的值,因此有 9 个组合)。每个组合需要在 T=10,N=250 的时间段内模拟 10000 次。对于所有这些模拟,必须应用 2 种交易策略 - MACD 和 RSI(在 TTR 包内)。 现在我遇到了编写代码的问题:(

#Geometrical Brownian Motion
Sim <- GBM(x, r, sigma, T, N)
x <-100
r <-0
sigma <-1
T <- 10
N <- 250

#Additional info for RSI-strategy
retSim <- ROC(Sim)
SimRSI <- RSI(Sim, 14,)
SimRSI[is.na(SimRSI)] <- 0

#Create a vector for the results of the inner loop
portfolio <- rep(0:N)
portfolio[1] <- 100

runs <- 10000

#Creating vectors for final results of portfolio and simulation after 10000 runs (only the last value of each of the 10000 simulations and portfolio results of the strategy required)
resultsSimGBM <- rep(0:runs)
resultsRSIr1sig1 <- rep(0:runs)

#orders
buyRSI<-portfolio[i-1]*exp(retSim[i])
holdRSI<-portfolio[i-1]

#Simulation
portfolio[1]<-100
i <- 1
j <- 1

#Second loop
for(j in 0:runs){

  #Simulation GBM

  x <-100
  r <-0
  sigma <-1
  T <- 10
  N <- 250
  Sim <- GBM(x, r, sigma, T, N)
  retSim <- ROC(Sim)
  SimRSI <- RSI(Sim, 14,)
  SimRSI[is.na(SimRSI)] <- 0
  portfolio[1] <- 100

  #First loop
  for(i in 2:length(Sim)){

    #Apply RSI on GBM
    buyRSI<-portfolio[i-1]*exp(retSim[i])
    holdRSI<-portfolio[i-1]

    if(SimRSI[i-1]<50 && SimRSI[i]>50){portfolio[i]=buyRSI}
    if(SimRSI[i-1]>50 && SimRSI[i]<50){portfolio[i]=holdRSI}
    if(SimRSI[i-1]<50 && SimRSI[i]<50){portfolio[i]=holdRSI}
    if(SimRSI[i-1]>50 && SimRSI[i]>50){portfolio[i]=buyRSI}
    i <- i+1
  }
  resultsRSI[j] <- portfolio[N]
  resultsSimGBM[j] <- Sim[N]
  j <- j+1
}

无论如何,这就是我到目前为止所拥有的,它似乎有效。但是,在第一个(内部)循环中,我还需要包含第二个策略(直到现在,它被单独列出)如下所示:

#MACD strategy
portfolioMACD[1]<-100
i <- 1
j <- 1

for(j in 0:runs){
  Sim <- BMSim
  retSim <- ROC(Sim)
  SimMACD <- MACD(Sim, 12, 26, 9, myType="EMA")
  DataSimMACD <- data.frame(SimMACD)
  DataSimMACD$macd[is.na(DataSimMACD$macd)] <- 0
  DataSimMACD$signal[is.na(DataSimMACD$signal)] <- 0

for(i in 2:length(Sim)){
  buyMACD<-portfolioMACD[i-1]*exp(retSim[i])
  sellMACD<-portfolioMACD[i-1]
  holdMACD<-portfolioMACD[i-1]*exp(retSim[i])
  if(DataSimMACD$macd[i-1]<DataSimMACD$signal[i-1] && DataSimMACD$macd[i]>DataSimMACD$signal[i]){portfolioMACD[i]=buyMACD}
  if(DataSimMACD$macd[i-1]>DataSimMACD$signal[i-1] && DataSimMACD$macd[i]<DataSimMACD$signal[i]){portfolioMACD[i]=sellMACD}
  if(DataSimMACD$macd[i-1]>DataSimMACD$signal[i-1] && DataSimMACD$macd[i]>DataSimMACD$signal[i]){portfolioMACD[i]=holdMACD}
  if(DataSimMACD$macd[i-1]<DataSimMACD$signal[i-1] && DataSimMACD$macd[i]<DataSimMACD$signal[i]){portfolioMACD[i]=sellMACD}
  if(DataSimMACD$macd[i]==DataSimMACD$signal[i]){portfolioMACD[i]=sellMACD}
  if(DataSimMACD$macd[i-1]==DataSimMACD$signal[i-1] && DataSimMACD$macd[i]!=DataSimMACD$signal[i]){portfolioMACD[i]=buyMACD}
  i <- i+1
}
  resultsMACD[j] <- portfolioMACD[length(Sim)]
  j <- j+1
}

基本上: 1-一个布朗运动必须由 2500 个元素组成,两种交易策略必须分别应用 2-对于变量 r 和 sigma (r1sigma1, r1sigma2, r1sigma3,.....,r3sigma3) 的 9 种组合中的每一种,整个过程必须重复 10000 次(这我还没有包含在我的代码中 -不知道如何围绕它构建这两个循环......):( 3-最终结果应该是一个 10000x27 矩阵,其中包含 10000 行(用于运行量)和 27 列(9x GBM、RSI、MACD),仅填充了每个模拟的第 2500 个(最终值)(从第 1 点开始。)--> 如何做吗?

求救!你们中的某个人可以帮我解决这个烂摊子吗?我完全迷路了,这是我的毕业论文-.-

每一次帮助都会受到高度赞扬和深深的感谢!

在此先感谢,很抱歉发了这么长的帖子。

来自柏林的干杯,安娜 :)

编辑和另一个简化示例

    library(sde)

    #Vectors for results
    Returns <- rep(0:N)
    LogReturns <- rep(0:N)
    Simulation <- rep(0:N)
    ResultsSimulation <- rep(0:runs)
    ResultsReturns <- rep(0:runs)
    ResultsLog <- rep(0:runs)

    runs=50   #how ofthen the Simulation of GBM should be repeated
    i <- 1
    j <- 1

    #second loop
    for(j in 2:runs){
      Simulation <- GBM(x, r, sigma, T, N)
      x=100
      r=0
      sigma=1
      T=1
      N=20

    #first loop
      for(i in 2:length(BM)){
        Returns <- ROC(Simulation)
        LogReturns[i+1] <- log(Simulation[i+1]/Simulation[i])

        i <- i+1
      }
      ResultsSimulation[j]<-Simulation[N]
      ResultsReturns[j]<-Returns[N]
      ResultsLog[j]<-LogReturns[N]

      j <- j+1
    }

ResultsMatrix <- as.matrix(data.frame(ResultsSimulation, ResultsReturns, ResultsLog))

这个例子的结构基本上是我的。我需要围绕它构建另外 2 个循环,它们将对 3 个不同的“r”值和“sigma”值(GBM 函数中的变量)进行相同的模拟和计算。结果(每个模拟的最终值和来自第一个循环的计算)应保存在单独的向量或由这些向量组成的矩阵中-> 因此,27 个长度为 50 的投资者(变量 r 和 sigma 的每个组合都有 3 个结果) 例如,如果 sigma=0.1; 0.3; 0,6 和 r=0,03; 0,05; 0,08

如何围绕它构建这些循环并相应地保存数据?

对不起,伙计们,但我真的迷路了:(

干杯,并提前非常感谢!至少是为了阅读;)

【问题讨论】:

  • 你应该提供一个最小的例子:stackoverflow.com/questions/5963269/…,而不是你的完整毕业论文。
  • 如果您可以像上面提到的@Ricardo 那样放大您遇到的确切问题,这对我们来说会更容易。
  • 嘿,抱歉,最初的帖子很大,我添加了一个简化的示例...希望现在更好...干杯:)
  • 这是基本编程,如果您提供完整的“流程”来说明您需要做什么,我可以为您提供帮助 - 阅读所有这些内容非常困难。

标签: r for-loop matrix


【解决方案1】:

这是否接近您的需要?如果是这样,您可以添加新的交易函数来返回投资组合,然后调用它(参见示例):

警告:运行 N_SIMS = 100000 大约需要 1.5 小时!

get.simulation.GBM = function(TIME = 10, N = 250, N_SIMS = 1000, x0 = 100, sigma = c(0.1, 0.3, 0.6), r = c(0.03, 0.05, 0.08))
{
  require(sde)
  params = expand.grid(sigma = sigma, r = r)
  
  # pre-allocate matrix
  results = matrix(0, ncol = N_SIMS * nrow(params), nrow = N)
  
  for (i in 1:nrow(params))
  {
    idx.range =  ((i - 1)*N_SIMS + 1):((i - 1)*N_SIMS + N_SIMS)
    temp.res = replicate(N_SIMS, GBM(x0, r = params[i, 'r'], sigma = params[i, 'sigma'], T = TIME, N = N - 1 ))
    results[, idx.range] = temp.res
  }
  
  return(results)
}

apply.MACD = function(serie, nFast = 12, nSlow = 26, nSig = 9, p0 = 100)
{
  require(TTR)
  roc = ROC(serie)
  sim.MACD = MACD(serie, nFast, nSlow, nSig, maType = "EMA")
  portfolio = rep(0, length = length(serie))
  portfolio[1] = p0
  
  sim.MACD[is.na(sim.MACD)] = 0
  sim.MACD = as.data.frame(sim.MACD)
  
  for (i in 2:length(serie))
  {
    buy = portfolio[i - 1] * exp(roc[i])
    sell = portfolio[i - 1]
    hold = buy
    
    if(sim.MACD$macd[i - 1] < sim.MACD$signal[i - 1] && sim.MACD$macd[i] > sim.MACD$signal[i]){portfolio[i] = buy}
    if(sim.MACD$macd[i - 1] > sim.MACD$signal[i - 1] && sim.MACD$macd[i] < sim.MACD$signal[i]){portfolio[i] = sell}
    if(sim.MACD$macd[i - 1] > sim.MACD$signal[i - 1] && sim.MACD$macd[i] > sim.MACD$signal[i]){portfolio[i] = hold}
    if(sim.MACD$macd[i - 1] < sim.MACD$signal[i - 1] && sim.MACD$macd[i] < sim.MACD$signal[i]){portfolio[i] = sell}
    if(sim.MACD$macd[i] == sim.MACD$signal[i]){portfolio[i] = sell}
    if(sim.MACD$macd[i - 1] == sim.MACD$signal[i - 1] && sim.MACD$macd[i] != sim.MACD$signal[i]){portfolio[i] = buy}
    
  }
  return(portfolio)
}

apply.RSI = function(serie, p0 = 100, n = 14)
{
  require(TTR)
  roc = ROC(serie)
  sim.RSI = RSI(serie, n = n)
  sim.RSI[is.na(sim.RSI)] = 0
  portfolio = rep(0, length = length(serie))
  portfolio[1] = p0
  
  for (i in 2:length(serie))
  {
    buy = portfolio[i - 1] * exp(roc[i])
    hold = portfolio[i - 1]
    
    if(sim.RSI[i - 1] < 50 && sim.RSI[i] > 50){portfolio[i] = buy}
    if(sim.RSI[i - 1] > 50 && sim.RSI[i] < 50){portfolio[i] = hold}
    if(sim.RSI[i - 1] < 50 && sim.RSI[i] < 50){portfolio[i] = hold}
    if(sim.RSI[i - 1] > 50 && sim.RSI[i] > 50){portfolio[i] = buy}
  }
  return(portfolio)
}

# Example (this is SLOW)
simulation.matrix = get.simulation.GBM()
portfolio.RSI = apply(simulation.matrix, 2, apply.RSI)
portfolio.MACD = apply(simulation.matrix, 2, apply.MACD)

# if you need only the last values
portfolio.RSI.last = tail(portfolio.RSI, 1)
portfolio.MACD.last = tail(portfolio.MACD, 1)

【讨论】:

  • 嗨费尔南多!感谢您的回答!它接近我所需要的。如何为每种参数组合运行 x(在您的代码 50 中)模拟?现在它给了我一个 250x50 矩阵,其中包含模拟 GBM 的所有值(而且我也不知道哪个模拟使用了哪些参数)基本上,我需要模拟一个 GBM,运行 2 个公式(2 个投资策略),保存只有 3 个向量(GBM 和 2 个策略)中每个向量的最后一个值。对于每个参数组合,这需要执行 x(在我的情况下特别是 10.000)次。在不丢失概述的情况下是否可行?干杯:)
  • 嗯...问题是我不知道您所说的“应用交易策略”是什么意思。最好的方法是为每个策略创建一个单独的函数,然后在其上使用 replicate()。你能简要描述一下这些策略是如何工作的吗? (我对财务一无所知!)
  • 问题是,我已经为 GBM 和策略的应用准备了代码。我不知道如何扩展代码以对所有其他参数组合执行相同的操作以及如何很好地保存它......基本上,模拟一个 GBM,然后(对于 1 个策略)应用一个函数(RSI)在计算 RSI 指数的 GBM 上。根据我写的索引和条件(例如,如果 RSI[i-1]50 thensimulatedRSI[i]=........等等)一个向量是在根据这些条件规则执行命令的位置创建(“买入”、“卖出”等)。我只需要最后一个.....
  • .....GBM 的值和那些创建的向量(在执行命令之后)。整个过程针对变量(r 和 sigma)x (10.000) 次的一个组合完成,只记录最后一个值。然后再进行 10000 次模拟,将策略与另一对变量等一起应用……我可以运行相同的东西,我已经有 9 次了,但是将它作为一个现成的程序并一次性完成会很好。 .. 对我来说另一个问题是如何将数据存储在一个矩阵中(27 个长度为 10000 的向量)或仅 9 个单独的矩阵,每个矩阵有 3 个向量......
  • 我需要在相同的 10000(x9) GBM 上运行这两种策略
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2015-06-12
  • 1970-01-01
  • 1970-01-01
  • 2022-01-09
  • 1970-01-01
  • 1970-01-01
  • 2021-06-03
相关资源
最近更新 更多