A mão a mão ensina-te a implantar uma estratégia para a língua Ma (progresso)

A mão a mão ensina-te a implantar uma estratégia para a língua Ma (progresso)

Artigo anteriorA mão ensinou-te a escrever estratégias - a transplante de uma estratégia da minha língua.Como é que se pode transpor uma estratégia para uma linguagem JavaScript que é um pouco mais complexa?

A primeira coisa que vamos ver é a estratégia de transplante:

(*backtest
start: 2019-05-01 00:00:00
end: 2019-11-12 00:00:00
period: 1d
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD"}]
args: [["SlideTick",10,126961],["ContractType","quarter",126961]]
*)

N1:=10;
N2:=21;
AP:=(HIGH+LOW+CLOSE)/3;
ESA:=EMA(AP,N1);
D:=EMA(ABS(AP-ESA),N1);
CI:=(AP-ESA)/(0.015*D);
TCI:=EMA(CI,N2);
WT1:TCI;
WT2:SMA(WT1,4,1);
AA:=CROSS(WT1,WT2);
BB:=CROSSDOWN(WT1,WT2);
REF(AA,1),BPK;
REF(BB,1),SPK;

A primeira parte da estratégia da língua Ma(*backtest...*)É o código de configuração do ajuste de retrospecção, para facilitar a comparação, definir uma configuração de retrospecção unificada. Esta estratégia também é uma estratégia de busca aleatória, não é muito complexa (relativamente mais complexa do que no artigo anterior), é uma estratégia mais representativa.EMA，SMA：

Uma roda inovadora

• EMA A função de indicador é uma função de biblioteca de indicadores já disponível quando a plataforma FMZ escreve políticas em JavaScript.TA.MA

• SMA O que precisamos de fazer é:SMAEste indicador, que descobrimos no banco de dados da FMZ que não suporta a função SMA, também tem diferenças entre o banco de dados da talib e o banco de dados da Maio:Como se pode ver, a parte dos parâmetros tem um parâmetro de peso, além do parâmetro de ciclo.

  A descrição da função de indicador SMA na biblioteca talib no documento FMZ API é:

  Veja.talib.SMAA média móvel é um indicador simples. E, assim, só podemos começar a fazer algo por nós mesmos.SMAÉ uma das habilidades necessárias para um desenvolvedor que escreve estratégias usando o JavaScript, pois, se não tiver rodas prontas, o carro ainda vai andar, basta construir uma.

  A verdade é que há poucas pesquisas sobre indicadores como esse, e geralmente não se sabe o que é pesquisar e procurar informações.

  O processo de algoritmo parece ser muito confiável, e vamos implementá-lo:

  function SMA (arr, n, m) {
      var sma = []
      var currSMA = null
      for (var i = 0; i < arr.length; i++) {
          if (arr[i] && !isNaN(arr[i])) {
              if (!currSMA) {
                  currSMA = arr[i]
                  sma.push(currSMA)
                  continue
              }  
  
              // [M*C2+(N-M)*S1]/N
              currSMA = (m * arr[i] + (n - m) * currSMA) / n
              sma.push(currSMA)
          } else {
              sma.push(NaN)
          }
      }  
  
      return sma
  }
  

Criação do preenchimento

Uso do quadro estratégicoA mão ensinou-te a escrever estratégias - a transplante de uma estratégia da minha língua.O artigo tem o mesmo quadro, mas é preenchido em duas partes:

O primeiro é processar dados do setor e calcular indicadores.

A partir daí, a linguagem foi desenvolvida de forma mais simples, com uma linguagem de programação mais simples e mais simples.

• 1、AP:=(HIGH+LOW+CLOSE)/3;

  Isso pode ser entendido como somar o preço máximo, mínimo e de fechamento de cada BAR na linha K, dividindo-o por 3, calcular a média e armazená-la como um conjunto, correspondendo a cada BAR. O que é que isso significa?

  function CalcAP (r) {   // AP:=(HIGH+LOW+CLOSE)/3;
      var arrAP = []      // 声明一个空数组
  
      for (var i = 0; i < r.length; i++) {      // r为传入的K线数据，是一个数组，用for遍历这个数组
          v = (r[i].High + r[i].Low + r[i].Close) / 3      // 计算 平均值
          arrAP.push(v)                                    // 添加在 arrAP数组的尾部，arrAP是空的时候尾部就是第一个。
      }  
  
      return arrAP     // 返回 这个平均值数组，即麦语言中计算的 AP 
  }
  

  A função OnTick pode ser chamada no ciclo principal, por exemplo:

  // 计算指标
  // AP
  var ap = CalcAP(records)
  

• Depois de concluído o cálculo AP, continue o cálculo.ESA:=EMA(AP,N1);:

  Aqui, para calcular o ESA, vamos usar o AP calculado no passo anterior, o ESA é a "média móvel do índice" do AP, ou seja, o indicador EMA, então podemos calcular o EMA usando o AP como dados e o N1 como parâmetros do indicador EMA.

  function CalcESA (ap, n1) {   // ESA:=EMA(AP,N1);
      if (ap.length <= n1) {    // 如果AP的长度小于指标参数，是无法计算出有效数据的，这个时候让函数返回false。
          return false
      }  
  
      return TA.EMA(ap, n1)
  }
  

• 3、D:=EMA(ABS(AP-ESA),N1);

  ComputaçãoAP、ESADados de cálculoDNão, não é. Aqui você pode ver a nota de código e algumas técnicas de cálculo de indicadores.

  function CalcD (ap, esa, n1) {    // D:=EMA(ABS(AP-ESA),N1);
      var arrABS_APminusESA = []
      if (ap.length != esa.length) {
          throw "ap.length != esa.length"
      }  
  
      for (var i = 0; i < ap.length; i++) {
          // 计算指标数值时，必须判断一下数据的有效性，因为前几次EMA计算可能数组中的开始部分的数据是NaN,或者null
          // 所以必须判断，参与计算的数据都是有效数值才能进行，如果有任何无效数值，就用NaN向arrABS_APminusESA填充
          // 这样计算得到的数据，每个位置和之前的数据都是一一对应的，不会错位。
          if (ap[i] && esa[i] && !isNaN(ap[i]) && !isNaN(esa[i])) {
              v = Math.abs(ap[i] - esa[i])     // 根据ABS(AP-ESA) , 具体计算数值,然后放入arrABS_APminusESA数组
              arrABS_APminusESA.push(v)
          } else {
              arrABS_APminusESA.push(NaN)
          }
      }  
  
      if (arrABS_APminusESA.length <= n1) {
          return false
      }  
  
      return TA.EMA(arrABS_APminusESA, n1)    // 计算数组arrABS_APminusESA的EMA指标，得到数据D（数组结构）
  }
  

• 4、CI:=(AP-ESA)/(0.015*D);Este método de cálculo é semelhante ao passo 1 e coloca o código diretamente.

  function CalcCI (ap, esa, d) {    // CI:=(AP-ESA)/(0.015*D);
      var arrCI = []
      if (ap.length != esa.length || ap.length != d.length) {
          throw "ap.length != esa.length || ap.length != d.length"
      }
      for (var i = 0; i < ap.length; i++) {
          if (ap[i] && esa[i] && d[i] && !isNaN(ap[i]) && !isNaN(esa[i]) && !isNaN(d[i])) {
              v = (ap[i] - esa[i]) / (0.015 * d[i])
              arrCI.push(v)
          } else {
              arrCI.push(NaN)
          }
      }  
  
      if (arrCI.length == 0) {
          return false
      }  
  
      return arrCI
  }
  

• TCI: = EMA ((CI, N2)); Apenas calcule o indicador EMA da matriz CI.

  function CalcTCI (ci, n2) {   // TCI:=EMA(CI,N2);
      if (ci.length <= n2) {
          return false
      }  
  
      return TA.EMA(ci, n2)
  }
  

• WT2:SMA(WT1,4,1);

  E o último passo, usando as rodas que construímos antes.SMAFunção.

  function CalcWT2 (wt1) {    // WT2:SMA(WT1,4,1);
      if (wt1.length <= 4) {
          return false 
      }  
  
      return SMA(wt1, 4, 1)   // 使用我们自己实现的SMA函数计算出wt1的SMA指标。
  }
  

A transferência de sinais de transação é muito simples.

AA:=CROSS(WT1,WT2);
BB:=CROSSDOWN(WT1,WT2);
REF(AA,1),BPK;
REF(BB,1),SPK;

A leitura destes códigos da língua Ma, pode ser visto como o golden fork, forks morto para os dois indicadores WT1 e WT2 linha de julgamento como condições para o início de negociação, é importante notar que o primeiro sinal cruzado é usado. A partir de uma análise direta da estratégia da língua Ma, observamos:

Observações realizadas com a estratégia da linguagem de Mac mostram que, quando o sinal é detectado no ponto de armazenamento, o ponto de armazenamento é detectado para verificar se a posição do BAR anterior aos dois BARs é uma forca de ouro.

O código de preenchimento da parte de detecção de sinal pode ser escrito como:

if ((_State == IDLE || _State == SHORT) && wt1[wt1.length - 4] < wt2[wt2.length - 4] && wt1[wt1.length - 3] > wt2[wt2.length - 3]) {
    if (_State == IDLE) {
        _State = OPENLONG
        Log("OPENLONG")    // 测试
    }
    if (_State == SHORT) {
        _State = COVERSHORT
        Log("COVERSHORT")  // 测试
    }
    isOK = false  
}

if ((_State == IDLE || _State == LONG) && wt1[wt1.length - 4] > wt2[wt2.length - 4] && wt1[wt1.length - 3] < wt2[wt2.length - 3]) {
    if (_State == IDLE) {
        _State = OPENSHORT
        Log("OPENSHORT")  // 测试
    }
    if (_State == LONG) {
        _State = COVERLONG
        Log("COVERLONG")  // 测试
    }
    isOK = false   
}

Aqui é possível pensar por que as instruções SPK e BPK da língua Ma podem ser implementadas com o código acima.

Revisão

Configurações de retest:

A versão em maquiana do texto reproduz:

Revisão do JavaScript:

O código da parte inicial da função OnTick, usado para acelerar um pouco a recuperação, é para que a estratégia seja executada em um modelo de preço de fechamento, que pode ser analisado em detalhes.

function OnTick(){
    // 驱动策略的行情处理部分
    var records = _C(exchange.GetRecords)
    if (records[records.length - 1].Time == preTime) {
        if (isOK) {
            Sleep(500)
            return 
        }
    } else {
        preTime = records[records.length - 1].Time
    }
    ...
    ..
    .

O código completo da estratégia de ensino:https://www.fmz.com/strategy/174457

Obrigado por ler.