Visualização e mudança de parâmetros estratégicos - versão 2

Esta é uma versão melhorada deste exemplo: https://strategyquant.com/doc/programming-for-sq/changing-strategy-parameters-programmatically/

O original EstratégiaParametersHelper A classe tinha apenas um método para alterar os valores dos parâmetros, mas não foi fácil obter a lista de parâmetros reais que a estratégia tem.

Então criamos uma nova versão - EstratégiaParametersHelperV2 classe, que também tem métodos para obter a lista de parâmetros e seus valores.

Ambas as classes estão disponíveis para download como anexos a este artigo.

Nota! Por causa de um pequeno problema no SQ você tem que primeiro importar e compilar o EstratégiaParametersHelperV2 classe, e somente após a importação e compilação do StrategyParameters classe.
Esta questão será resolvida no próximo SQ Build 136.

EstratégiaParametersHelperV2 tem estes métodos:

• setParameters() - define (modifica) os parâmetros
• getParameterNames() - retorna uma lista de nomes de parâmetros
• getParameterValues() - retorna uma lista de nomes e valores de parâmetros
• toString() - converte a lista de parâmetros do método anterior para uma cadeia legível

Podemos ver como ele pode ser usado no exemplo de um trecho do banco de dados:

pacote SQ.Colunas.Bancos de dados;

importação SQ.Utils.StrategyParametersHelperV2;
import com.strategyquant.lib.L;
import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;
import com.strategyquant.lib.ValuesMap;

classe pública StrategyParameters extends DatabankColumn {

    Parâmetros de estratégia pública() {
        super(L.tsq("Parâmetros de Estratégia"), DatabankColumn.Text, ValueTypes.Maximize, 0, 0, 1);

        setWidth(200);
    }
    
    //------------------------------------------------------------------------

    @Override
    público duplo getNumericValue(ResultadosResultadosResultados do grupo, String resultKey, byte direction, byte plType, byte sampleType) lança Exceção {
        retornar 0;
    }

    //------------------------------------------------------------------------
    
    @Override
    public String getValue(ResultadosResultadosResultados do grupo, resultado da StringKey, direção do byte, byte plType, byte sampleType) lança Exceção {
        tente {
            ValoresParâmetroMapaTipos = novos ValoresMapa();
            parameterTypes.set(ParametrizationTypes.ParamTypePeriod, true);
            parâmetroTypes.set(ParametrizationTypes.ParamTypeShift, falso);
            parameterTypes.set(ParametrizationTypes.ParamTypeConstant, false);
            parameterTypes.set(ParametrizationTypes.ParametrizationTypes.ParamTypeOtherParam, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLevel, true);
            parâmetroTypes.set(ParametrizationTypes.ParamTypeEntryLogic, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUnused, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeBoolean, false);
            parameterTypes.set(ParametrizationTypes.ParametrizationTypeTradingOptions, false);

            boolean sameVariablesForLongShort = true;

            return StrategyParametersHelperV2.toString(StrategyParametersHelperV2.getParameterValues(results, parameterTypes, sameVariablesForLongShort));
        catch(Exceção e) } catch(Exceção e) {
            retornar "Erro": " + e.getMessage();
        }
    }
}

Você pode ver que usamos o método helper para obter parâmetros e depois convertê-los em string.

O resultado (nova coluna de banco de dados) terá o seguinte aspecto - listará os parâmetros especificados de determinada estratégia:

Observe que você pode definir quais tipos de parâmetros deseja ver, e também se deseja usar a mesma variável para os lados longo e curto - o mesmo que você pode fazer no Optimizer ou em outros ajustes de parâmetros.

O código completo de EstratégiaParametersHelperV2 classe é:

pacote SQ.Utils;

import com.strategyquant.datalib.datalib.TradingException;
import com.strategyquant.lib.SQTime;
import com.strategyquant.lib.ValuesMap;
importar com.strategyquant.lib.XMLUtil;
importar com.strategyquant.tradinglib.*;
importar com.strategyquant.tradinglib.options.TradingOptionsList;
importar com.strategyquant.tradinglib.propertygrid.IPGParameter;
import com.strategyquant.tradinglib.propertygrid.ParametersTableItemProperties;
import org.jdom2.Element;
importação org.slf4j.Logger;
importação org.slf4j.LoggerFactory;

importação java.util.ArrayList;
importação de java.util.HashMap;
importação java.util.List;
importação de java.util.map;

classe pública StrategyParametersHelperV2 {

    logger final estático público = LoggerFactory.getLogger(StrategyParametersHelper.class);

    valor final estático público String ValueDelimiter = "=";
    public static final String ParamDelimiter = ",",";

    /**
     * Aplica valores de parâmetros na estratégia
     * @param rg
     * @param parameters - lista de parâmetros delimitada por dois pontos e seus valores - por exemplo param1=123,param2=25,4
     * @param symmetricVariables
     * @param modifyLastSettings
     * @throws Exceção
     */
    conjunto de parâmetros estáticos públicosParâmetros estáticos(ResultadosParâmetros de grupo, String, boolean symmetricVariables, boolean modifyLastSettings) lança Exceção {

        //Load XML e atualizar variáveis
        StrategyBase StrategyBase = getStrategyBase(rg, symmetricVariables);
        Variáveis variáveis = strategyBase.variables();

        String[] params = parameters.split(ParamDelimiter);
        HashMap paramMap = novo HashMap();

        for(int i=0; i<params.length; i++) {
            String[] values = params[i].split(ValueDelimiter);
            paramMap.put(valores[0], valores[1]);
        }

        for(int a=0; a<variables.size(); a++) {
            Variable variable = variables.get(a);
            if(paramMap.containsKey(variable.getName())) {
                variable.setFromString(paramMap.get(variable.getName()));
            }
        }

        strategyBase.transformToNumbers();

        rg.portfolio().addStrategyXml(strategyBase.getStrategyXml());
        rg.specialValues().setString(StatsKey.OPTIMIZATION_PARAMETERS, parâmetros);

        if(modificarLastSettings){
            tente {
                Elemento LastSettings = XMLUtil.stringToElement(rg.getLastSettings()));
                Element elParams = lastSettings.getChild("Options").getChild("BuildTradingOptions").getChild("Params");
                Lista paramElems = elParams.getChildren("Param");

                ListaOpções Comerciais = TradingOptionsList.getInstance().getAvailableClasses();

                for(String paramName : paramMap.keySet()) {
                    processado booleano = falso;

                    // devemos encontrar a opção comercial correta
                    for(int i=0; i<tradingOptions.size(); i++) {
                        se(processado) quebra;

                        Opção TradingOption = tradingOptions.get(i);
                        String optionClass = option.getClass().getSimpleName();
                        ArrayList optionParams = option.getParams();

                        // passar por seus paramédicos e encontrar aquele com o nome correspondente
                        for(int z=0; z<optionParams.size(); z++) {
                            se(processado) quebra;

                            IPGParameter optionParameter = optionParams.get(z);
                            String paramKey = optionParam.getKey();

                            if(!optionParam.getName().equals(paramName)) continua;

                            //agenda encontrar o elemento de parâmetro correto nas configurações XML e atualizar seu valor
                            for(int s=0; s<paramElems.size(); s++) {
                                Element elParam = paramElems.get(s);
                                String elParamClass = elParam.getAttributeValue("className");
                                String elParamKey = elParam.getAttributeValue("chave");

                                if(elParamClass != null && elParamKey != null && elParamClass.equals(optionClass) && elParamKey.equals(paramKey)) {
                                    String value = paramMap.get(paramName);

                                    if(optionParam.getType() == ParametrosTableItemProperties.TYPE_TIME) {
                                        valor = "" + SQTime.HHMMToMinutes(Integer.parseInt(valor)) * 60;
                                    }

                                    elParam.setText(valor);

                                    processado = verdadeiro;
                                    pausa;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings));
            }
            catch(Exceção e){
                Log.error("Não é possível aplicar parâmetros de opções comerciais às últimas configurações", e);
            }
        }
    }

    /**
     * Retorna uma lista de nomes de parâmetros estratégicos
     * @param rg
     * @param parameterTypes
     * @param symmetricVariables
     * @retorno
     * @throws Exceção
     */
    public static ArrayList getParameterNames(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        HashMap paramsMap = getParameterValues(rg, parâmetroTypes, symmetricVariables);

        ArrayList lista = nova ArrayList();
        list.addAll(paramsMap.keySet());

        lista de retorno;
    }

    /**
     * Devolve um mapa contendo nomes e valores de parâmetros estratégicos
     * @param rg
     * @param parameterTypes - ValuesMap especificando ParametrizationTypes para verificar. Se nulos, os tipos de parâmetros recomendados são usados.
     * @param symmetricVariables
     * @retorno
     * @throws Exceção
     */
    public static HashMap getParameterValues(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        StrategyBase StrategyBase = getStrategyBase(rg, symmetricVariables);
        Variáveis variáveis = strategyBase.variables();

        HashMap paramsList = novo HashMap();

        boolean useRecommended = parâmetroTypes == null || parameterTypes.getBoolean(ParametrizationTypes.ParamTypeRecommended, false);

        if(useRecomendado){
            parâmetroTipos = novos valoresMapa();
            parâmetroTypes.set(ParametrizaçãoTypes.ParamTypePeriod, verdadeiro);
            parâmetroTypes.set(ParametrizationTypes.ParamTypeEntryLevel, verdadeiro);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
        }

        for(int a=0; a<variables.size(); a++) {
            Variable variable = variables.get(a);
            String variableType = variable.getParamType();

            String varName = variable.getName();
            if(varName.equals("LongEntrySignal") ||| varName.equals("ShortEntrySignal") ||| varName.equals("LongExitSignal") ||| varName.equals("ShortExitSignal") ||| varName.equals("MagicNumber")) {
                // saltar parâmetros que não precisam ser definidos aqui
                continuar;
            }

            if(variableType == nulo || parameterTypes.getBoolean(variableType, false)){
                paramsList.put(variável.getName(), variável.getValue()));
            }
        }

        devolver paramsList;
    }

    /**
     * Retorna um valor de parâmetro selecionado
     * @param rg
     * @param symmetricVariables
     * @param parameterName
     * @retorno
     * @throws Exceção
     */
    public static String getParameterValue(ResultsGroup rg, boolean symmetricVariables, String parameterName) lança Exceção {
        StrategyBase StrategyBase = getStrategyBase(rg, symmetricVariables);
        Variáveis variáveis = strategyBase.variables();
        Variable variable = variables.get(parâmetroNome);

        if(variável == nulo) retorna nulo;

        variável.getValue();
    }

    /**
     * Converte o mapa de parâmetros em cadeia
     * @param parametersMap
     * @retorno
     */
    public static String toString(HashMap parametersMap){
        if(parametersMap == nulo) retorna nulo;

        StringBuilder sb = novo StringBuilder();

        for(String name : parametersMap.keySet()){
            sb.append(ParamDelimiter);
            sb.append(nome);
            sb.append(ValueDelimiter);
            sb.append(parametersMap.get(name));
        }

        retornar sb.length() > ParamDelimiter.length() ? sb.substring(ParamDelimiter.length()) : sb.toString();
    }

    private static StrategyBase getStrategyBase(ResultsGroup rg, boolean symmetricVariables) lança Exceção {
        StrategyBase xmlS = StrategyBase.createXmlStrategy(rg.getStrategyXml());
        xmlS.transformToVariables(symmetricVariables);
        retornar xmlS;
    }

}