Anzeigen und Ändern von Strategieparametern - Version 2

Dies ist eine verbesserte Version dieses Beispiels: https://strategyquant.com/doc/programming-for-sq/changing-strategy-parameters-programmatically/

Das Original StrategyParametersHelper Klasse hatte nur eine Methode zum Ändern der Parameterwerte, aber es war nicht einfach, die Liste der aktuellen Parameter der Strategie zu erhalten.

Also haben wir eine neue Version erstellt - StrategieParameterHelferV2 Klasse, die auch Methoden zum Abrufen der Liste der Parameter und ihrer Werte enthält.

Beide Klassen stehen als Anhänge zu diesem Artikel zum Download bereit.

Hinweis! Wegen eines kleinen Problems in SQ müssen Sie zuerst das Programm importieren und kompilieren. StrategieParameterHelferV2 Klasse, und erst danach importieren und kompilieren Sie die StrategieParameter Klasse.
Dieses Problem wird im nächsten SQ Build 136 behoben.

StrategieParameterHelferV2 hat diese Methoden:

• setParameters() - setzt (ändert) die Parameter
• getParameterNames() - gibt eine Liste von Parameternamen zurück
• getParameterValues() - gibt eine Liste von Parameternamen und -werten zurück
• toString() - wandelt die Liste der Parameter der vorherigen Methode in eine lesbare Zeichenkette um

Im Beispiel-Datenbank-Snippet können wir sehen, wie es verwendet werden kann:

Paket SQ.Columns.Databanks;

import SQ.Utils.StrategyParametersHelperV2;
import com.strategyquant.lib.L;
import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;
import com.strategyquant.lib.ValuesMap;

public class StrategyParameters extends DatabankColumn {

    public StrategyParameters() {
        super(L.tsq("Strategieparameter"), DatabankColumn.Text, ValueTypes.Maximize, 0, 0, 1);

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

    @Override
    public double getNumericValue(ResultsGroup results, String resultKey, byte direction, byte plType, byte sampleType) throws Exception {
        return 0;
    }

    //------------------------------------------------------------------------
    
    @Override
    public String getValue(ResultsGroup results, String resultKey, byte direction, byte plType, byte sampleType) throws Exception {
        try {
            ValuesMap parameterTypes = new ValuesMap();
            parameterTypes.set(ParametrizationTypes.ParamTypePeriod, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeShift, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeConstant, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeOtherParam, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLevel, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLogic, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUnused, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeBoolean, false);
            parameterTypes.set(ParametrizationTypes.ParamTypeTradingOptions, false);

            boolean sameVariablesForLongShort = true;

            return StrategyParametersHelperV2.toString(StrategyParametersHelperV2.getParameterValues(results, parameterTypes, sameVariablesForLongShort));
        } catch(Exception e) {
            return "Fehler: " + e.getMessage();
        }
    }
}

Sie sehen, dass wir die Hilfsmethode verwenden, um Parameter zu erhalten und sie dann in eine Zeichenkette umzuwandeln.

Das Ergebnis (neue Datenbankspalte) wird wie folgt aussehen - es wird die angegebenen Parameter der gegebenen Strategie auflisten:

Beachten Sie, dass Sie festlegen können, welche Parametertypen Sie sehen möchten und auch, ob Sie dieselbe Variable für die lange und die kurze Seite verwenden möchten - so wie Sie es auch im Optimierer oder in anderen Parametereinstellungen tun können.

Der vollständige Code von StrategieParameterHelferV2 Klasse ist:

Paket SQ.Utils;

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

import java.util.ArrayList;
import java.util.HashMap; import java.util;
import java.util.List; import java.util;
import java.util.Map;

public class StrategyParametersHelperV2 {

    public static final Logger Log = LoggerFactory.getLogger(StrategyParametersHelper.class);

    public static final String ValueDelimiter = "=";
    public static final String ParamDelimiter = ",";

    /**
     * Übernimmt Parameterwerte in die Strategie
     * @param rg
     * @param parameters - durch Doppelpunkt getrennte Liste von Parametern und deren Werten - z.B. param1=123,param2=25.4
     * @param symmetricVariables
     * @param modifyLastSettings
     * @throws Exception
     */
    public static void setParameters(ResultsGroup rg, String parameters, boolean symmetricVariables, boolean modifyLastSettings) throws Exception {

        //Laden von XML und Aktualisieren von Variablen
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variablen Variablen = strategyBase.variables();

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

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

        for(int a=0; a<variablen.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, parameters);

        if(modifyLastSettings){
            try {
                Element lastSettings = XMLUtil.stringToElement(rg.getLastSettings());
                Element elParams = lastSettings.getChild("Optionen").getChild("BuildTradingOptions").getChild("Params");
                List paramElems = elParams.getChildren("Param");

                List tradingOptions = TradingOptionsList.getInstance().getAvailableClasses();

                for(String paramName : paramMap.keySet()) {
                    boolean processed = false;

                    //wir müssen die richtige Handelsoption finden
                    for(int i=0; i<tradingOptions.size(); i++) {
                        if(verarbeitet) break;

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

                        //Die Parameter durchgehen und denjenigen mit dem passenden Namen finden
                        for(int z=0; z<optionParams.size(); z++) {
                            if(verarbeitet) break;

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

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

                            //jetzt das richtige Param-Element im Einstellungs-XML finden und seinen Wert aktualisieren
                            for(int s=0; s<paramElems.size(); s++) {
                                Element elParam = paramElems.get(s);
                                String elParamClass = elParam.getAttributeValue("className");
                                String elParamKey = elParam.getAttributeValue("key");

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

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

                                    elParam.setText(value);

                                    verarbeitet = true;
                                    break;
                                }
                            }
                        }
                    }
                }

                rg.setLastSettings(XMLUtil.elementToString(lastSettings));
            }
            catch(Exception e){
                Log.error("Cannot apply trading options params to last settings", e);
            }
        }
    }

    /**
     * Gibt eine ArrayList von Strategie-Parameternamen zurück
     * @param rg
     * @param parameterTypes
     * @param symmetricVariables
     * @return
     * @throws Exception
     */
    public static ArrayList getParameterNames(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        HashMap paramsMap = getParameterValues(rg, parameterTypes, symmetricVariables);

        ArrayList list = new ArrayList();
        list.addAll(paramsMap.keySet());

        Liste zurückgeben;
    }

    /**
     * Gibt eine Karte mit den Namen und Werten der Strategieparameter zurück
     * @param rg
     * @param parameterTypes - ValuesMap, die die zu prüfenden ParametrizationTypes angibt. Wenn null, werden die empfohlenen Parametertypen verwendet.
     * @param symmetricVariables
     * @Rückgabe
     * @throws Exception
     */
    public static HashMap getParameterValues(ResultsGroup rg, ValuesMap parameterTypes, boolean symmetricVariables) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variables variables = strategyBase.variables();

        HashMap paramsList = new HashMap();

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

        if(useRecommended){
            parameterTypes = new ValuesMap();
            parameterTypes.set(ParametrizationTypes.ParamTypePeriod, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeEntryLevel, true);
            parameterTypes.set(ParametrizationTypes.ParamTypeExitUsed, true);
        }

        for(int a=0; a<variablen.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")) {
                // Parameter, die hier nicht gesetzt werden müssen, werden übersprungen
                fortfahren;
            }

            if(variableType == null || parameterTypes.getBoolean(variableType, false)){
                paramsList.put(variable.getName(), variable.getValue());
            }
        }

        return paramsList;
    }

    /**
     * Gibt den Wert des ausgewählten Parameters zurück
     * @param rg
     * @param symmetricVariables
     * @param parameterName
     * @return
     * @throws Exception
     */
    public static String getParameterValue(ResultsGroup rg, boolean symmetricVariables, String parameterName) throws Exception {
        StrategyBase strategyBase = getStrategyBase(rg, symmetricVariables);
        Variablen Variablen = strategyBase.variables();
        Variable variable = variables.get(parameterName);

        if(variable == null) return null;

        return variable.getValue();
    }

    /**
     * Konvertiert Parameter-Map in String
     * @param parametersMap
     * @Rückgabe
     */
    public static String toString(HashMap parametersMap){
        if(parametersMap == null) return null;

        StringBuilder sb = new StringBuilder();

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

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

    private static StrategyBase getStrategyBase(ResultsGroup rg, boolean symmetricVariables) throws Exception {
        StrategyBase xmlS = StrategyBase.createXmlStrategy(rg.getStrategyXml());
        xmlS.transformToVariables(symmetricVariables);
        return xmlS;
    }

}