Reconhecendo resultados na Matriz WF em torno do campo personalizado

O pedido original:

existe uma maneira de escolher uma célula específica no WFM que um certo número de células de substituição tem que ter Pass?
ou seja, quero ter um WFM aprovado, se 4 células que se sobrepuserem às 10 corridas e a célula 20%OOS tiverem um resultado aprovado. Não quero que o SQX escolha a melhor célula de acordo com os resultados ao redor, mas quero definir qual célula eu preciso para ter células passadas ao redor.

Sim, é possível, a maneira mais fácil de fazê-lo é usando o snippet de Análise Personalizada que pode ser iniciado logo após a otimização.

Código de snippet comentado da CustomAnalysis:

pacote SQ.CustomAnalysis;

importação org.slf4j.Logger;
importação org.slf4j.LoggerFactory;

import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.optimization.WalkForwardMatrixResult;

classe pública CAWFMCheck estende o método CustomAnalysisMethod {
    logger final estático público = LoggerFactory.getLogger("CAWFMCheck");
    
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    //------------------------------------------------------------------------
    
    público CAWFMCheck() {
        super("CA WFM check", TYPE_FILTER_STRATEGY);
    }
    
    //------------------------------------------------------------------------
    
    @Override
    filtro booleano públicoEstratégia(projeto String, tarefa String, banco de dados StringName, ResultsGroup rg) lança Exceção {

        // quantos vizinhos devem passar para que a WF Matrix passe?
        int neighboursToPass = 3;

        // encontrar o resultado WF desejado na estratégia ResultsGroup - em nosso caso 10 Runs e 20% OOS
        WalkForwardResult wfResult;
        tente {
            wfResult = findWFResult(rg, 20, 10); // 10 Runs e 20%OOS
        catch(Exceção e) } catch(Exceção e) {
            Log.info("WFResultado não encontrado: "+ e.getMessage());

            retornar verdadeiro;
        }

        // criar a matriz WFM como matriz bidimensional
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        WalkForwardResult[][] wfMatrix = createMatrix(wfm);
        
        int matrixRows = wfMatrix.length;
        int matrixColumns = wfMatrix[0].length;

        // agora passe por esta matriz bidimensional e procure por vizinhos de nosso resultado WF escolhido
        for(int rowIndex=0; rowIndex<matrixRows; rowIndex++) {
            for(int colIndex=0; colIndex<matrixColumns; colIndex++) {
                
                if(wfMatrix[rowIndex][colIndex].param1 == wfResult.param1 && wfMatrix[rowIndex][colIndex].param2 == wfResult.param2) {
                    //WF posição do resultado encontrado na matriz, verificar vizinhos
                    int neighboursPassed = 0;
                    int neighboursChecked = 0;
                    
                    for(int neighbourRowIndex=rowIndex-1; neighbourRowIndex<=rowIndex+1; neighbourRowIndex++) {
                        if(neighbourRowIndex=matrixRows) {
                            continuar;
                        }
                        
                        for(int neighbourColIndex=colIndex-1; neighbourColIndex<=colIndex+1; neighbourColIndex++) {
                            if(neighborColIndex=matrixColumns) {
                                continuar;
                            }
                            
                            if(neighbourRowIndex==rowIndex && neighbourColIndex==colIndex) {
                                continuar;
                            }
                            
                            WalkForwardResultado wfResultadoNeighbour = wfMatrix[neighborRowIndex][neighborColIndex];
                            if(wfResultNeighbour.pass) {
                                vizinhosPassed+++;
                            }
                            
                            vizinhosChecked+++;
                        }
                    }
                    
                    Log.info(String.format("Neighbours checked %d / passed %d", neighboursChecked, neighboursPassed));

                    // encontrou o resultado da WF, passou por vizinhos verificados. Comparar com o valor limiar
                    return neighboursPassed >= neighboursToPass;
                }
            }
        }
        
        retornar falso;
    }
    
    //------------------------------------------------------------------------
    
    private WalkForwardResult FindWFResult(ResultsGroup rg, int param1, int param2) lança Exceção {
        WalkForwardMatrixResult wfm = (WalkForwardMatrixResult) rg.mainResult().get(SettingsKeys.WalkForwardResult);
        if(wfm==nulo) {
            lançar nova Exceção ("WFMatrixResultado não encontrado");
        }
        
        return wfm.getWFResult(param1, param2);
    }
    
    //------------------------------------------------------------------------

    private WalkForwardResult[][] createMatrix(WalkForwardMatrixResult wfm) throws Exception {
        int filas = 0;
        colunas int = 0;

        for(int j=wfm.start2; j<=wfm.stop2; j+=wfm.increment2) filas+++;
        for(int i=wfm.start1; i<=wfm.stop1; i+=wfm.increment1) colunas+++;
            
        WalkForwardResult[][] wfMatrix = novo WalkForwardResult[filas][colunas];

        int param1Index = 0;
        int param2Index = 0;
        
        for(int j=wfm.start2; j<=wfm.stop2; j+=wfm.increment2) {
            for(int i=wfm.start1; i<=wfm.stop1; i+=wfm.increment1) {
                WalkForwardResult wfResult = wfm.getWFResult(i, j);
              				
                wfMatrix[param2Index][param1Index] = wfResultado;
                param1Index++;
            }
                        
            param2Index++;
            param1Index=0;
        }
        
        retornar wfMatrix;
    }
}