¿Cómo Volver.de la cartera y de Regreso.el reequilibrio de trabajo en el Desempeño de Analítica en R?

Question

Tengo una pregunta acerca de la función Return.portfolio/Return.rebalancing del Rendimiento del paquete de análisis en R.

Me tome el ejemplo descrito en el paquete:

> data(edhec)
> data(weights)
> Return.portfolio(edhec,weights = weights)
           portfolio.returns
2000-01-31      0.0115135339
2000-02-29      0.0218963077
2000-03-31      0.0093379014
2000-04-30      0.0037485690
2000-05-31      0.0056601357
2000-06-30      0.0140301727
2000-07-31      0.0043295816
2000-08-31      0.0190997787
2000-09-30      0.0014645727
2000-10-31      0.0014264155
2000-11-30      0.0061304707
2000-12-31      0.0201417025
2001-01-31      0.0150594011
2001-02-28      0.0066011872
2001-03-31      0.0131395159
2001-04-30      0.0007491561
2001-05-31      0.0091626407
2001-06-30     -0.0000527803
2001-07-31      0.0020738201
2001-08-31      0.0102713727
2001-09-30      0.0002531717
2001-10-31      0.0142380976
2001-11-30     -0.0048429083
2001-12-31      0.0061645640
2002-01-31      0.0093372403
2002-02-28     -0.0011217258
2002-03-31      0.0063415238
2002-04-30      0.0082130861
2002-05-31      0.0058782220
2002-06-30      0.0007565192
2002-07-31     -0.0059246865
2002-08-31      0.0072696705
2002-09-30      0.0026434591
2002-10-31      0.0014298494
2002-11-30      0.0105008400
2002-12-31      0.0127186414
2003-01-31      0.0159481947
2003-02-28      0.0092381495
2003-03-31      0.0001639493
2003-04-30      0.0113937775
2003-05-31      0.0199355028
2003-06-30      0.0020659339
2003-07-31     -0.0039260851
2003-08-31      0.0035691334
2003-09-30      0.0114224214
2003-10-31      0.0116788871
2003-11-30      0.0069773935
2003-12-31      0.0117366500
2004-01-31      0.0137408298
2004-02-29      0.0086731496
2004-03-31      0.0030241495
2004-04-30     -0.0031369461
2004-05-31     -0.0006375207
2004-06-30      0.0039463036
2004-07-31      0.0010463350
2004-08-31      0.0022005523
2004-09-30      0.0065116125
2004-10-31      0.0042086646
2004-11-30      0.0164591318
2004-12-31      0.0094498415
2005-01-31      0.0030113644
2005-02-28      0.0103238498
2005-03-31      0.0008083756
2005-04-30     -0.0052241413
2005-05-31      0.0020622011
2005-06-30      0.0081079582
2005-07-31      0.0118744372
2005-08-31      0.0073621313
2005-09-30      0.0101843734
2005-10-31     -0.0012149988
2005-11-30      0.0076005987
2005-12-31      0.0089111835
2006-01-31      0.0193600000
2006-02-28      0.0050290768
2006-03-31      0.0122895863
2006-04-30      0.0161541728
2006-05-31      0.0028728086
2006-06-30      0.0008591674
2006-07-31      0.0029350825
2006-08-31      0.0061800530
2006-09-30      0.0020263120
2006-10-31      0.0128266559
2006-11-30      0.0129600658
2006-12-31      0.0126486355
2007-01-31      0.0106456451
2007-02-28      0.0105816673
2007-03-31      0.0082080685
2007-04-30      0.0120657529
2007-05-31      0.0130340469
2007-06-30      0.0054403426
2007-07-31     -0.0001698053
2007-08-31     -0.0096513313
2007-09-30      0.0156251014
2007-10-31      0.0171940678
2007-11-30     -0.0113391902
2007-12-31      0.0030447149
2008-01-31     -0.0120408215
2008-02-29      0.0045617517
2008-03-31     -0.0188804492
2008-04-30      0.0121140702
2008-05-31      0.0127356881
2008-06-30     -0.0003266534
2008-07-31     -0.0118233426
2008-08-31     -0.0064733095
2008-09-30     -0.0478450597
2008-10-31     -0.0630740252
2008-11-30     -0.0354050961
2008-12-31     -0.0046962342
2009-01-31      0.0089404911
2009-02-28     -0.0027223978
2009-03-31      0.0050820481
2009-04-30      0.0229829814
2009-05-31      0.0374323984
2009-06-30      0.0111071893
2009-07-31      0.0255805068
2009-08-31      0.0179835194
Warning message:
In Return.portfolio(edhec, weights = weights) :
  number of assets in beginning_weights is less than number of columns in returns, so subsetting returns.
> sum(as.numeric(edhec[151,1:11])*as.numeric(weights[8,]))
[1] 0.02614121
>

Cómo son estos retornos calculados usando Return.portfolio? En pesos son de dos columnas que faltan en comparación con edhec. Esa es la razón por la que me llevó a

edhec[151,1:11]

Por otra parte, vemos que los pesos es una xts objeto con sólo 8 filas. No Return.portfolio revisa las fechas y tener el derecho de pesos para ese período? Por otra parte, ¿cuál es la diferencia a Return.rebalancing?

Es correcto, que si hemos de resumir los primeros 10 elementos de

Return.portfolio(edhec,weights = weights)

nos gustaría obtener la rentabilidad total en el tiempo $t=10$?

Referencia: el paquete de software en uso es de R lenguaje de programación se utiliza para el análisis y visualización de datos con estadísticas y gráficos. R es una suite integrada de software de instalaciones para la manipulación de datos, el cálculo y la visualización gráfica. La R del proyecto es de código Abierto, disponible en http://www.r-project.org/

Además, el programa estadístico R cuenta con un gran repositorio de proyectos disponibles para toda la comunidad, disponible en https://r-forge.r-project.org/ Uno de los proyectos es ReturnAnalytics -- de Rendimiento y análisis de riesgos financieros las series de tiempo, incluyendo los paquetes PerformanceAnalytics y PortfolioAnalytics. Que el proyecto está disponible a través de acceso anónimo: svn checkout svn://svn.r-forge.r-project.org/svnroot/returnanalytics/

Answer 1

Me enteré de que la parte superior de la serie de tiempo es el resultado de una llamada

    > tail(Return.rebalancing(edhec,weights))
           portfolio.returns
2009-03-31       0.005082048
2009-04-30       0.022982981
2009-05-31       0.037432398
2009-06-30       0.011107189
2009-07-31       0.025580507
2009-08-31       0.017983519

(por la óptica de la comparación. ;-) )

Una mirada al código revela que el outpout es el resultado de sucesivas llamadas (bucle for) a Return.portfolio(), tomando como entrada el regreso unicc entre dos fechas diferentes y la weight vector correspondiente a la fecha de inicio del intervalo de tiempo.

En resumen: Se crea una serie de tiempo de un reajuste de la cartera donde el reequilibrio de las fechas y los pesos se dan por weights.

Eso es lo que los rendimientos se calculan Return.portfolio().

También, para las dos columnas adicionales cuestión me enteré, que Return.portfolio() tiene una línea en la que se selecciona a la derecha de las columnas, de manera efectiva, haciendo algo como edhec[,colnames(weights[1,])]

Answer 2

Voy a separar el problema en dos.

La clave de lo que estás pidiendo es que ¿cómo Volver.el reequilibrio de tratar sus diferentes frequencied y el número de activos de retorno y el peso de los objetos.

Datos fotográficos:

Es subconjuntos de la primera ncol(peso) de las columnas de R (como ncol(edhec) > ncol(pesos)

ncol R es ahora de 11 años. Comprueba si la primera fecha en R es menor que la primera fecha de la fecha en W Si es cierto que los subconjuntos de R de 2000-01-02/" a partir de nrow(I) es ahora 116 como usted no puede tener un retorno de la serie antes de que los pesos iniciales.

Procesamiento de datos:

A continuación, llama a Volver.de la cartera.geométrica, que sólo multiplica la devolución por parte de los pesos de los dos matrices.

Como los pesos son anuales y edhec es mensual.

Que necesita para calcular los demás años

Así que agarra el regreso de la serie para el medio plazo.

Recorre todos los de la devolución de la subserie el cálculo de los pesos * la cantidad anterior, en el periodo de retorno (esencialmente flotante y reequilibrar el peso de la matriz). Se toma el valor total de cada período en el regreso de la serie y lo divide por el valor inicial en el período para calcular el retorno periódico.

Una simple demostración es como sigue.

1. Tome inicial valor de la equidad (1)
2. Tomar reequilibrio año inicial de peso
3. Calcular final de período de capital (inicial de acciones * peso * retorno)
4. Calcular el retorno para el período

5. Repita dos en cada reequilibrio de la fecha especificada en la matriz de pesos.

   eop_value[k ] = (1 + coredata(devuelve[j ])) * bop_value[k ] eop_value_total[k] = sum(eop_value[k ])

   ret[k] = eop_value_total[k]/end_value - 1 end_value = eop_value_total[k]

El código anterior se calcula el nuevo capital total en cada posición y lo resume.

Por lo que es similar a su peso flotantes y, a continuación, restablecer en cada fecha en los pesos de la matriz.