Algoritmos para la realización de las simulaciones

Texto completo

(1)

Algoritmos para la realización de las simulaciones

D.1 Algoritmo para los experimentos

Puesto que todos los algoritmos utilizados para realizar los experimentos son iguales excepto por la definición del vector v(d), se muestra solamente uno de ellos.

function [aciertos] = crearExperimentoD(datos, horizonte)

%Definicion y normalizacion de valores pasados como argumento for k=1:size(datos,2)

maxcol = max(max(datos(:,k,:)));

datos(:,k,:) = datos(:,k,:)/maxcol;

end

cierre = datos(:,1);

%Numero de dias hacia atras que contiene el vector v antelacion = 2;

%Intervalo entre dos dias para determinar si hay subida o bajada. Ej intervalo=2 -> valor(Hoy)-valor(anteayer) intervalo = 1;

%Definicion de los tiempos en la simulacion ventana = size(datos,1);

proptest = 0.3; %Porcion de tiempo del test en una simulacion test = max(15, round(ventana*proptest)); %Duracion del test aprendizaje = ventana - test; %Duracion del aprendizaje

fintest = ventana-horizonte; %horizonte se usa para definir el final del test. Sera 0 al buscar el optimo

(2)

D.1 Algoritmo para los experimentos

%Determinar si longitud de los datos pasados es suficiente if intervalo+antelacion>aprendizaje

aciertos = [NaN, NaN];

else

%Inicializacion de conjuntos

S = []; %Conjunto de puntos de subida B = []; %Conjunto de puntos de bajada

%Inicializacion de conjuntos de test STest = [];

BTest = [];

ok_Minus = 0;

ok_Plus = 0;

for d=intervalo+antelacion:fintest

%Cada dia (d) se asocia a un vector de caracteristicas y a un set (S o B)

v=[cierre(d-1), cierre(d-2)];

incremento = cierre(d) - cierre(d-intervalo);

%Aprendizaje if d<=aprendizaje

if incremento >= 0 %cierre(d)>cierre(d-1)

%punto(d-1) al set de subida S = cat(1, S, v);

else

% punto(d-1) al set de bajada B = cat(1, B, v);

end

if d==aprendizaje

%Clasificador de puntos. theta_c define el hiperplano de separacion

theta_c = Clasificador(B,S);

if isempty(theta_c) || norm(theta_c) == 0 aciertos = [NaN, NaN];

return end

end

%Test else

if incremento >= 0

STest = cat(1, STest, v);

if (STest(end,:)*theta_c > 0)

%Si v(d) esta encima del hiperplano → prediccion correcta

ok_Plus = ok_Plus + 1;

end else

BTest = cat(1, BTest, v);

if (BTest(end,:)*theta_c < 0)

%Si v(d) esta debajo del hiperplano → prediccion correcta

ok_Minus = ok_Minus + 1;

(3)

end end

if d == fintest

acierto_Plus = ok_Plus/size(STest,1)*100;

acierto_Minus = ok_Minus/size(BTest,1)*100;

aciertos = [acierto_Plus, acierto_Minus];

end end

end end

D.2 Filtrado de outliers

function puntos = eliminarOutliers(puntos, idvol, umbral)

%Funcion que elimina valores outliers de los datos pasados como

%argumento.

%Recibe tambien el limite a superar por los incrementos para que

%un punto sea considerado outlier.

%Devuelve los datos de entrada despues de eliminar los elementos

%outliers.

if ~isempty(puntos)

%Filtrado por volumen

salto = 0; %numero dias hacia adelante para calcular la media rango = 2:size(puntos,1);

columnas = 1:size(puntos,2);

columnas = columnas(columnas~=idvol);

for empresa=1:size(puntos,3)

volumen = puntos(:,idvol,empresa);

volmedio = mean(volumen);

%para todas las columnas excepto el volumen for columna=columnas

vector = puntos(:,columna,empresa);

a = vector(1:end-1);

b = vector(2:end);

inc = abs((b-a)./a);

excluir = find(inc>umbral)+1;

excluir = excluir(volumen(excluir)<volmedio);

excluir = excluir(excluir<=rango(end)-salto);

mediaoutlier =...

mean([vector(excluir+salto)';vector(excluir-1)']);

puntos(excluir,columna,empresa) = mediaoutlier';

end end

end end

(4)

D.3 Simulación de búsqueda del tamaño óptimo de la ventana

D.3 Simulación de búsqueda del tamaño óptimo de la ventana

%Limpiar variables y ventanas clc, close all, clear variables

%Variables del fichero

dir = ['./Resultados/', mfilename('file'),'/'];

if exist(dir,'dir') == 0 mkdir(dir);

end

%Crear instancia de BD.

o = BD;

%Otras variables

vol = 5; %Indice de la columna de volumen. Usado en outliers cie = 4; %Indice de la columna de cierre.

ape = 1; %Indice de la columna de apertura.

years = 2001:2012;

for a=years

%Definir datos y consultar historico

%Consultar datos indice = {'^IBEX'};

columnas = o.columnas;

rango = {['01/12/',num2str(a-1)] '-' ['31/12/',num2str(a)]};

[fechas, idc, ide, puntos] = ...

o.consultarBD(rango, columnas, indice);

%Obtener elementos con valor distinto a NOTDEF [r,c,v] = ind2sub(size(puntos(:,cie,:)),...

find(puntos(:,cie,:) == o.NOTDEF));

idf = setdiff(1:length(fechas), unique(r));

fechas = fechas(idf);

puntos = puntos(idf,:,:);

%Eliminar outliers

puntos = eliminarOutliers(puntos,vol,0.02);

%Parametros de ventana movil intervalo = length(fechas);

experimentos = 50; %Numero de experimentos que se haran por cada intervalo. A mayor valor mayor suavizado

ventanas = 30:round(intervalo/experimentos):intervalo;

desplazamiento = 7; %Tiempo que se desplaza la ventana

%Bucle para cambiar longitud de la ventana resultados = [];

for ventana=ventanas %Duracion de la ventana a estudiar

(5)

%Bucle para moverse dentro de una ventana aciertos = [];

for k=0:desplazamiento:intervalo-ventana inicio = k + 1;

fin = k + ventana;

rango = inicio:fin;

%EXPERIMENTO 1

[acierto1] = crearExperimentoS(...

puntos(rango,[ape cie]), 0);

%EXPERIMENTO 2

[acierto2] = crearExperimentoD(...

puntos(rango,cie), 0);

%EXPERIMENTO 3

[acierto3] = crearExperimentoM(...

puntos(rango,[ape cie vol]), 0);

%EXPERIMENTO 4

[acierto4] = crearExperimentoG(...

puntos(rango,[ape cie vol]), 0);

%Acumulador de aciertos

aciertos = cat(1, aciertos,...

[acierto1, acierto2, acierto3, acierto4]);

end

%Finaliza una ventana, acumular estadisticas media = nanmean(aciertos,1);

resultados = cat(1, resultados, media);

end

%Presentar resultados comparativos entre experimentos close all

set(0,'DefaultFigureWindowStyle','docked') subplot(5,1,1);

plot(puntos(:,cie),'b-');

xlim([1 size(puntos,1)]);

xlabel('Fecha');

ylabel('Cierre');

ylim('auto');

grid on

subplot(5,1,[2 3]);

plot(ventanas', resultados(:,1:2:end));

xlabel('ventana');

ylabel('Acierto subida');

xlim([ventanas(1) ventanas(end)]);

ylim([0 100]);

grid on

subplot(5,1,[4 5]);

plot(ventanas', resultados(:,2:2:end));

xlabel('ventana');

(6)

D.3 Simulación de búsqueda del tamaño óptimo de la ventana

ylabel('Acierto bajada');

xlim([ventanas(1) ventanas(end)]);

ylim([0 100]);

leyenda = legend('expS', 'expD', 'expM', 'expG');

set(leyenda,'Position',[0.78 0.11 0.12 0.14],'FontSize',8);

grid on

%Guardar figura

fichero =['opt_a',num2str(a),'-

d',num2str(desplazamiento),'.fig'];

saveas(gcf, [dir, fichero], 'fig');

end

D.4 Simulación de la cartera permanente

%Limpiar variables y ventanas clc, close all, clear variables

%Definir directorios

dir1 = ['./Resultados/', mfilename('file'),'/'];

dir2 = [dir1,'ParamTasa/'];

dir3 = [dir1,'ParamSaldo/'];

dir4 = [dir1,'ParamVista/'];

if ~exist(dir1,'dir')

mkdir(dir1); mkdir(dir2); mkdir(dir3); mkdir(dir4);

end

%Crear instancia de la clase BD o = BD;

%Matrices de resultados

rentabilidades = []; emp_anuales = [];

M_anuales = []; P_anuales = [];

%Parametros:

%Años de la simulación years = 2001:2012;

%Dias vista que se quieren predecir diasvista = 7:2:15;

%Saldo inicial en cuenta

saldosinicio = [50000:25000:125000,150000:100000:350000];

%Tasas de acierto minimas para tomar decision tasasacierto = 60:5:80;

%Consultar historico indice = {'^IBEX'};

[~,ide] = o.historiaIndice(['20/11/',num2str(years(1)-1)],...

['31/12/',num2str(years(end))], indice, 10);

empresas = o.empresas(ide);

(7)

columnas = {'Apertura' 'Cerrar' 'Volumen'};

vol = 3; %Indice de la columna de volumen. Usado en outliers cie = 2; %Indice de la columna de cierre.

ape = 1; %Indice de la columna de apertura.

%Comienza la simulacion for vista=diasvista for saldo=saldosinicio for sub=tasasacierto for baj=tasasacierto for a=years

% Definir datos

rangofechas = {['20/11/',num2str(a-1)],'-',...

['31/12/',num2str(a)]};

[fechas, idc, ide, puntos] = o.consultarBD(rangofechas,...

columnas, empresas);

% Definición del fondo de inversion

[~, ~, ~, cierrefondo] = o.consultarBD(rangofechas,...

columnas(cie), indice);

comisionfondo = 2.25 + 0.2;

cierrefondo = cierrefondo(cierrefondo~=o.NOTDEF);

%Obtener elementos con valor distinto a NOTDEF valoresdef = prod(double(puntos~=o.NOTDEF),2);

%Datos y variables de la cartera de inversion

cuenta = saldo; %Donde esta el dinero para invertir. Liquidez n_empresas = length(empresas); %Numero de empresas en cartera inversion = zeros(n_empresas,5); %Inversión en cada empresa valores = 1:n_empresas; %Empresas de la cartera

%Subdividir el vector de fechas

ventana = max(50,min(vista*10,120)); %intervalo entre 50 y 120 intervalo = length(fechas); %Longitud de los datos de un año

%Acumuladores y otras variables

n_exp = 4; %Numero de experimentos utilizados

aciertoinvdia = []; %Almacena acierto del decisor diariamente resultadodia = []; %Dinero en cuenta+inversion diario

subfechas = []; %Almacena lista de fechas con datos utiles operacionesdia = []; %Numero de operaciones realizadas al dia rango = [];

closing = [];

valoresdia = [];

inicio = 0;

%Buscar conjuntos de puntos contiguos while inicio<intervalo

inicio = inicio+1;

nocero = valoresdef(inicio,:)~=0;

%Comprobar si hay al menos una empresa disponible

(8)

D.4 Simulación de la cartera permanente

if sum(nocero)

valores = valores.*nocero;

rango = cat(2,rango,inicio);

%Si se eliminan todas las empresas reiniciar if sum(valores)==0

inicio = rango(1)+1;

%Reiniciar vectores valores = 1:n_empresas;

rango = [];

%Comprobar si ya se tienen datos para la ventana elseif length(rango) == ventana

inicio = rango(1)+vista;

fin = rango(end);

valoresok = valores(valores~=0);

aciertodiaaux =...

zeros(size(valoresok,2),2*n_exp);

%Tomar cierre antes de filtrar outliers subpuntos = puntos(rango,:,:);

cierre = zeros(ventana,n_empresas);

cierre(:,valoresok) =...

subpuntos(:,cie,valoresok);

%Eliminar outliers

subpuntos(:,:,valoresok) =...

eliminarOutliers(...

subpuntos(:,:,valoresok),vol,0.02);

%Bucle de experimentos

parfor k=1:size(valoresok,2)

%EXPERIMENTO 1

[acierto1] = crearExperimentoS(...

subpuntos(:,[ape cie],...

valoresok(k)), vista);

%EXPERIMENTO 2

[acierto2] = crearExperimentoD(...

subpuntos(:,cie,.valoresok(k)),vista);

%EXPERIMENTO 3

[acierto3] = crearExperimentoM(...

subpuntos(:,[ape cie vol],...

valoresok(k)), vista);

%EXPERIMENTO 4

[acierto4] = crearExperimentoG(...

subpuntos(:,[ape cie vol],...

valoresok(k)), vista);

(9)

%Acumuladores diarios aciertodiaaux(k,:) = ...

[acierto1,acierto2,acierto3,acierto4];

end

aciertodia = zeros(n_empresas,2*n_exp);

aciertodia(valoresok,:) = aciertodiaaux;

%Decisor de inversiones

[aciertoinv,operaciones,cuenta,inversion]...

= decisionInversion(cierre,vista,cuenta,...

inversion,valoresok,aciertodia,sub,baj);

%Actualizar acumuladores aciertoinvdia = ...

cat(2,aciertoinvdia,aciertoinv);

resultadodia = cat(1,resultadodia,...

[cuenta,sum(inversion(:,1))]);

subfechas = cat(1, subfechas, fin);

closing = cat(1, closing, sum(cierre,2));

operacionesdia = ...

cat(2, operacionesdia, operaciones);

valoresdia = ...

cat(2, valoresdia, length(valoresok));

%Reiniciar vectores valores = 1:n_empresas;

rango = [];

end end

end

%Acumular datos para las estadisticas n_dias = size(subfechas,1);

acierto_Plus=100*sum(aciertoinvdia(:,1:2:end),1)./...

sum(operacionesdia(:,1:2:end),1);

acierto_Minus=100*sum(aciertoinvdia(:,2:2:end),1)./...

sum(operacionesdia(:,2:2:end),1);

acierto_empresas=100*sum(aciertoinvdia,2)./...

sum(operacionesdia,2);

rentfondo = 100*(cierrefondo(end)-cierrefondo(1))/...

cierrefondo(1)-comisionfondo;

rentcartera = 100*(sum(resultadodia(end,:))-saldo)/saldo;

rentabilidades = cat(1, rentabilidades,...

[vista,saldo,sub,baj,a,rentcartera,...

rentfondo(rentcartera>=rentfondo)]);

P_anuales = cat(2,P_anuales,acierto_Plus);

M_anuales = cat(2,M_anuales,acierto_Minus);

emp_anuales = cat(2,emp_anuales,acierto_empresas);

end end end end end

(10)

D.4 Simulación de la cartera permanente

%Guardar resultados y estadisticas para su posterior análisis positivos = rentabilidades((rentabilidades(:,6)>=0),:);

negativos = rentabilidades((rentabilidades(:,6)<0),:);

subtotales = 100*[sum(positivos(:,8)==1)/size(positivos,1),...

sum(negativos(:,8)==1)/size(negativos,1)];

save([dir1,'Resultados.mat'],'rentabilidades','subtotales',...

'P_anuales','M_anuales', 'emp_anuales');

D.5 Simulaciones de la cartera diaria

%Limpiar variables y ventanas clc, close all, clear variables

%Definir directorios

dir1 = ['./Resultados/', mfilename('file'),'/'];

dir2 = [dir1,'ParamTasa/'];

dir3 = [dir1,'ParamSaldo/'];

dir4 = [dir1,'ParamVista/'];

if ~exist(dir1,'dir')

mkdir(dir1); mkdir(dir2); mkdir(dir3); mkdir(dir4);

end

%Crear instancia de la clase BD o = BD;

%Matrices de resultados

rentabilidades = []; emp_anuales = [];

M_anuales = []; P_anuales = [];

%Parametros:

%Años de la simulación years = 2001:2012;

%Dias vista que se quieren predecir diasvista = 7:2:15;

%Saldo inicial en cuenta

saldosinicio = [50000:25000:125000,150000:100000:350000];

%Tasas de acierto minimas para tomar decision tasasacierto = 60:5:80;

%Comienza la simulacion for vista=diasvista for saldo=saldosinicio for sub=tasasacierto for baj=tasasacierto for a=years

%Subdividir el vector de fechas

ventana = max(50,min(vista*10,120)); %intervalo entre 50 y 120

(11)

indice = {'^IBEX'};

empresas = o.empresas;

columnas = {'Apertura' 'Cerrar' 'Volumen'};

vol = 3; %Indice de la columna de volumen. Usado en outliers cie = 2; %Indice de la columna de cierre.

ape = 1; %Indice de la columna de apertura.

% Definición del fondo de inversion rangofechas = ...

{['20/11/',num2str(a-1)],'-',['31/12/',num2str(a)]};

[~, ~, ~, cierrefondo] = o.consultarBD(rangofechas,...

columnas(cie), indice);

comisionfondo = 2.25 + 0.2;

cierrefondo = cierrefondo(cierrefondo~=o.NOTDEF);

%Longitud total de los datos de un año intervaloaux = ...

{['20/11/',num2str(a-1)], ['31/12/',num2str(a)]};

intervalonum = o.convertirFecha(intervaloaux);

fechasaux = intervalonum(1):intervalonum(end);

intervalo = length(fechasaux);

%Datos y variables de la cartera de inversion

cuenta = saldo; %Donde esta el dinero para invertir. Liquidez n_empresas = length(empresas); %Numero de empresas en cartera inversion = zeros(n_empresas,5); %Inversión en cada empresa valoresini = 1:n_empresas; %Empresas de la cartera

%Acumuladores y otras variables

n_exp = 4; %Numero de experimentos utilizados

aciertoinvdia = []; %Almacena acierto del decisor diariamente resultadodia = []; %Dinero en cuenta+inversion diario

subfechas = []; %Almacena lista de fechas con datos utiles operacionesdia = []; %Numero de operaciones realizadas al dia rango = [];

closing = [];

valoresdia = [];

inicio = 1;

while inicio<=intervalo

% Definir datos

if fechasaux(1)+inicio+ventana*1.5>length(o.fechas) fin = length(o.fechas);

else

fin = fechasaux(1)+inicio+ventana*1.5;

end

rangofechas = o.fechas(fechasaux(1)+inicio-1:fin);

[~,ide] = o.historiaIndice(rangofechas{1},...

rangofechas{end}, indice, 10);

[~, ~, ide, puntos] = o.consultarBD(rangofechas,...

columnas, o.empresas(ide));

n_empresas2 = length(ide);

(12)

D.5 Simulaciones de la cartera diaria

valores = 1:n_empresas2; %Empresas de la cartera

%Obtener elementos con valor distinto a NOTDEF valoresdef = prod(double(puntos ~= o.NOTDEF),2);

inicio2 = 0;

rango = [];

while inicio2 < size(valoresdef,1) inicio2 = inicio2 + 1;

nocero = valoresdef(inicio2,:)~=0;

%Comprobar si hay al menos una empresa disponible if sum(nocero)

valores = valores.*nocero;

rango = cat(2,rango,inicio2);

%Si se eliminan todas las empresas reiniciar if sum(valores)==0

inicio2 = rango(1)+1;

%Reiniciar vectores valores = 1:n_empresas2;

rango = [];

%Comprobar si hay datos para la ventana elseif length(rango) == ventana

inicio2 = size(valoresdef,1);

inicio = inicio + rango(vista) - 1;

valoresok = valores(valores~=0);

aciertodiaaux =...

zeros(size(valoresok,2),2*n_exp);

%Tomar cierre antes de filtrar subpuntos = puntos(rango,:,:);

cierre = zeros(ventana,n_empresas2);

cierre(:,valoresok) =...

subpuntos(:,2,valoresok);

%Eliminar outliers

subpuntos(:,:,valoresok) =...

eliminarOutliers(...

subpuntos(:,:,valoresok),vol,0.02);

%Bucle de experimentos

parfor k=1:size(valoresok,2)

%EXPERIMENTO 1

[acierto1] = crearExperimentoS(...

subpuntos(:,[ape cie],...

valoresok(k)), vista);

%EXPERIMENTO 2

(13)

[acierto2] = crearExperimentoD(...

subpuntos(:,cie,.valoresok(k)),vista);

%EXPERIMENTO 3

[acierto3] = crearExperimentoM(...

subpuntos(:,[ape cie vol],...

valoresok(k)), vista);

%EXPERIMENTO 4

[acierto4] = crearExperimentoG(...

subpuntos(:,[ape cie vol],...

valoresok(k)), vista);

%Acumuladores diarios aciertodiaaux(k,:) = ...

[acierto1,acierto2,acierto3,acierto4];

end

aciertodia =...

zeros(n_empresas2,2*n_exp);

aciertodia(valoresok,:) =...

aciertodiaaux;

%Decisor de inversiones

[aciertoinv,operaciones,cuenta,...

inversion(ide,:)] =...

decisionInversion(...

cierre,vista,cuenta,...

inversion(ide,:),valoresok,...

aciertodia,sub,baj);

%Actualizar acumuladores aux = zeros(n_empresas,2);

aux(ide,:) = aciertoinv;

aciertoinvdia = ...

cat(2,aciertoinvdia,aux);

resultadodia = ...

cat(1, resultadodia, ...

[cuenta,sum(inversion(:,1))]);

subfechas = ...

cat(1,subfechas, inicio+rango(end)-1);

closing = ...

cat(1, closing, sum(cierre,2));

aux(ide,:) = operaciones;

operacionesdia = ...

cat(2, operacionesdia, aux);

valoresdia = ...

cat(2, valoresdia, length(valoresok));

end end

end

if isempty(rango)

inicio = inicio + 1;

(14)

D.5 Simulaciones de la cartera diaria

elseif length(rango) < ventana

if inicio == inicio + rango(1) - 1 inicio = intervalo + 1;

else

inicio = inicio + rango(1) - 1;

end end

end

%Acumular datos para las estadisticas n_dias = size(subfechas,1);

acierto_Plus=100*sum(aciertoinvdia(:,1:2:end),1)./...

sum(operacionesdia(:,1:2:end),1);

acierto_Minus=100*sum(aciertoinvdia(:,2:2:end),1)./...

sum(operacionesdia(:,2:2:end),1);

acierto_empresas=100*sum(aciertoinvdia,2)./...

sum(operacionesdia,2);

rentfondo = 100*(cierrefondo(end)-cierrefondo(1))/...

cierrefondo(1)-comisionfondo;

rentcartera = 100*(sum(resultadodia(end,:))-saldo)/saldo;

rentabilidades = cat(1, rentabilidades,...

[vista,saldo,sub,baj,a,rentcartera,...

rentfondo(rentcartera>=rentfondo)]);

P_anuales = cat(2,P_anuales,acierto_Plus);

M_anuales = cat(2,M_anuales,acierto_Minus);

emp_anuales = cat(2,emp_anuales,acierto_empresas);

end end end end end

%Guardar resultados y estadisticas para su posterior análisis positivos = rentabilidades((rentabilidades(:,6)>=0),:);

negativos = rentabilidades((rentabilidades(:,6)<0),:);

subtotales = 100*[sum(positivos(:,8)==1)/size(positivos,1),...

sum(negativos(:,8)==1)/size(negativos,1)];

save([dir1,'Resultados.mat'],'rentabilidades','subtotales',...

'P_anuales','M_anuales', 'emp_anuales');

(15)

D.6 Algoritmo de toma de decisiones

function[aciertoinv, operaciones, cuenta, inversion] = ...

decisionInversion(cierre,vista,cuenta,inversion,valores,aciertodia,s ub,baj)

% Funcion que decide cuando comprar/vender acciones en funcion

% de la tasa de acierto pasada como argumento

%

% Entrada:

% - cierre. Datos de cierre del indice

% - vista. Num dias vista a predecir

% - cuenta.

% - inversion.

% - aciertodia. Tasa de acierto de los experimentos

%

% Salida:

% - aciertoinv. Dice si inversor acierta o no

% - cuenta

% - inversion

%

% Parametros:

% - tasa acierto subida/bajada (en %)

% - proporcion experimentos sobre tasa acierto (0...1)

% - minima compra/venta (0...1)

% - minimo en cuenta (0...)

% - minimo en cartera (0...)

%Parametros del decisor subida = sub; bajada = baj;

prop = 0.5;

mincompra = 0.5; minventa = 0.5;

mincuenta = 0; mincartera = 0;

%Datos y variables del decisor d = size(cierre,1);

cartera = size(inversion,1);

sube = zeros(cartera,1); baja = zeros(cartera,1);

ejecutar = 1;

acierto_Plus = aciertodia(:,1:2:end);

decisor_Plus = sum(acierto_Plus>=subida,2);

media_Plus = nanmean(acierto_Plus,2);

acierto_Minus = aciertodia(:,2:2:end);

decisor_Minus = sum(acierto_Minus>=bajada,2);

media_Minus = nanmean(acierto_Minus,2);

comprar = max([mincompra*ones(cartera,1),media_Plus/100],[],2);

vender = max([minventa*ones(cartera,1),media_Minus/100],[],2);

(16)

D.6 Algoritmo de toma de decisiones

% Decisor basado en resultados de experimentos for k=valores

% El dia (d-vista) decidir la accion, dia (d-vista+1) ejecutar if decisor_Plus(k)*prop > decisor_Minus(k)

if inversion(k,4)==1 %ultima operacion fue de venta operacion = inversion(k,2);

if cierre(d-vista+1,k)>inversion(k,5) ejecutar = 0;

end

elseif inversion(k,4)==2 %ultima operacion fue de compra operacion = 3200*comprar(k);

else %es la primera operacion operacion = 3200*comprar(k);

end

gastos = gastosOperacion(operacion);

if ejecutar && cuenta>operacion+gastos+mincuenta

%si queda dinero en cuenta para compensar gastos sube(k) = 1;

cuenta = cuenta - operacion - gastos;

inversion(k,:) = [inversion(k,1)+operacion,...

operacion,operacion+gastos, 2, cierre(d-vista+1)];

end

elseif decisor_Minus(k)*prop > decisor_Plus(k)

if inversion(k,4)==1 %ultima operacion fue de venta operacion = inversion(k,1)*vender(k);

elseif inversion(k,4)==2 %ultima operacion fue de compra operacion = inversion(k,2);

if inversion(k,2)<inversion(k,3)+...

gastosOperacion(operacion)

%si existe beneficio desde la compra ejecutar = 0;

end

else %es la primera operacion operacion = 0;

end

gastos = gastosOperacion(operacion);

if ejecutar && inversion(k,1)>operacion+mincartera &&...

operacion>gastos

%si liquidar operacion compensa gastos en cuenta baja(k) = 1;

inversion(k,:) = [inversion(k,1)-operacion,...

operacion,operacion-gastos, 1, cierre(d-vista+1)];

cuenta = cuenta + operacion - gastos;

end end

end

(17)

%El dia (d) actualizar valor de las inversiones variacion = ...

(cierre(d,:) - cierre(d-vista+1,:))'./cierre(d-vista+1,:)';

inversion(valores,1:2) = inversion(valores,1:2).*...

[(1+variacion(valores)),(1+variacion(valores))];

%Determinar acierto de la operacion

ok_Plus = zeros(cartera,1); ok_Minus = zeros(cartera,1);

ok_Plus(valores) = sube(valores).*(variacion(valores)>=0);

ok_Minus(valores) = baja(valores).*(variacion(valores)<0);

aciertoinv = [ok_Plus, ok_Minus];

operaciones = [sube, baja];

end

Figure

Actualización...

Referencias

Actualización...

Related subjects :