O recurso está a ser carregado... Carregamento...

Doc MyLanguage

Autora:Inventor quantificado - sonho pequeno, Criado: 2022-06-30 18:24:06, Atualizado: 2024-02-06 17:36:19

[TOC]

O MyLanguage é uma linguagem de negociação programática que é compatível e aprimorada com o MyLanguage. O MyLanguage do FMZ Quant passará por uma verificação de sintaxe rigorosa.%%O operador fará com que seja notificado um erro.

Instruções básicas
- Contrato
  
  Contrato de criptomoeda
  
  Contrato de criptomoeda
```
this_week     cryptocurrency futures contract this week
next_week     cryptocurrency futures contract next week
month         cryptocurrency futures contract month
quarter       cryptocurrency futures contract quarter
next_quarter  cryptocurrency futures contract next quarter
third_quarter cryptocurrency futures contract third quarter
last_quarter  contract last quarter

XBTUSD        BITMEX perpetual contract
swap          cryptocurrency futures perpetual contracts other than BITMEX exchange

For details, please refer to the exchange.SetContractType() function section of the JavaScript/Python/C++ documentation
```
- Variaveis
  
  Uma variável é um espaço aberto na memória do computador para armazenar dados.
  
  abre a primeira variável
```
// assign 1 to variable a
a:=1;
```
  EmMyLanguage, é fácil de distinguir dodata volume:
  1. Dados de valor único: existe apenas um valor, como:0, 1, 'abc'.
  2. Dados de sequência: uma sequência de dados composta por um conjunto de dados de valor único, tais como:Close(preço de encerramento), ondeClosecontém o preço de encerramento den periods. [ 10.1 , 10.2 , 10.3 , 10.4 , 10.5 ...]
  Distinguir de tipo variável
  1. Tipo de cadeia: deve ser envolto com ````, não é permitido o uso direto do tipo de cadeia e precisa ser exibido na vista com a função.
```
INFO(CLSOE>OPEN,'OK!');
```
  1. Tipos de valores: incluindo números inteiros, números com vírgula flutuante (decimais).
```
// integer
int:=2;

// decimal
float:=3.1;
```
  1. Tipo booleano, usando 1 (para verdadeiro) ou 0 (para falso): 1, 0, verdadeiro ou falso.A:=1>0;Após este código ser executado, o valor deAé 1.
```
// The closing price of the current period is greater than -999, you will find that the return value of each period is 1, which means true, because the closing price is almost impossible to be negative.
is_true:=Close>-999;
```
  1. Variaveis globais
```
VARIABLE:VALUE1:10;     // Declare a global variable, assign the value 10, and execute it only once.
```
  Observe que ao fazer backtesting:
```
VARIABLE:NX:0;    // The initial global variable NX is 0
NX..NX+1;         // Accumulate 1 each time
INFO(1,NX);       // Print NX every time
```
  Inicialmente, oINFOImpressões de declarações101Talvez não seja.0No início? A razão é que há 100 linhas iniciais K no backtest, e 100 linhas K já foram executadas, que foi acumulado 100 vezes. O preço real depende de quantas linhas K são inicialmente obtidas.
  - Regras de nomeação
    
    Na maioria dos sistemas, a nomeação de variáveis não permite o uso de palavras reservadas (nomes de variáveis incorporados, nomes de funções).Close, CAlém disso, não são permitidos números puros ou números principais. Na verdade, você não precisa se preocupar com a eficiência do sistema principal de análise de chinês. Acredito que o MyLanguage é muito amigável ao chinês. Para programadores experientes, é recomendável que você use as seguintes duas regras de nomeação:
    1. Nome chinês
```
// elegant output
5-day moving average:=MA(C,5);
```
    1. Inglês + sublinhado
```
// Output
move_avg_5:=MA(C,5);
```
    Se você preferir o inglês, tente tornar o significado de suas variáveis o mais compreensível possível.A1, AAA, BBBConfie em mim, quando você revisar o seu código de indicador novamente em alguns dias, você vai ser muito infeliz devido à perda de memória.
    
    Assim, a partir de agora, abrace o MyLanguage ao máximo! Espero que possa tornar-se uma ferramenta poderosa para a sua análise e tomada de decisão.
- Tipo de dados
  
  Tipo de dados é um conceito básico. Quando atribuímos dados claros a uma variável por escrito, a variável também se torna o tipo dos próprios dados.
  - 1. Tipo de valor:
```
1.2.3.1.1234.2.23456 ...
```
  - 1. Tipo de cadeia (str):
```
'1' .'2' .'3' ，String types must be wrapped with ''
```
  - 1. Dados de sequência:
```
A collection of data consisting of a series of single-valued data
```
  - 1. Tipo booleano:
    Utilização1representatruee0parafalse.
    
    Exemplo
```
// declare a variable of value type
var_int := 1;
// Declare a variable for sequence data
var_arr := Close;
// The string type cannot be declared alone, it needs to be combined with the function
INFO(C>O, 'positive line');
```
- Operador
  
  A operação e o cálculo utilizados para executar o código do indicador são simplesmente os símbolos envolvidos na operação.
  - Operador de atribuição
    
    para atribuir um valor a uma variável
    - 1. :
      :, representa a atribuição e saída para o gráfico (subgrafo).
```
Close1:Close;      // Assign Close to the variable Close1 and output to the figure
```
    - 1. :=
      :=, representa a atribuição, mas não é emitido para o gráfico (gráfico principal, subgráfico...), nem é exibido na tabela da barra de estado.
```
Close2:=Close;     // Assign Close to the variable Close2
```
    - 1. ^^
      ^^Dois.^Os símbolos representam a atribuição, atribuem valores às variáveis e saem para o gráfico (gráfico principal).
```
lastPrice^^C;
```
    - 1. ..
      ..Dois..Os símbolos representam a atribuição, atribuem valores às variáveis e exibem os nomes e valores das variáveis no gráfico, mas não desenham imagens para o gráfico (imagem principal, subimagem...).
```
openPrice..O
```
  - Operadores relacionais
    
    Os operadores relacionais são operadores binários que são usados em expressões condicionais para determinar a relação entre dois dados.
    
    Valor de retorno: Tipo booleano, quertrue(1) oufalse(0).
    - 1. mais de>
```
// Assign the operation result of 2>1 to the rv1 variable, at this time rv1=1
rv1:=2>1;
```
    - 1. Menos de<
```
// Returns false, which is 0, because 2 is greater than 1
rv3:=2<1;
```
    - 1. superior ou igual a>=
```
x:=Close;
// Assign the result of the operation that the closing price is more than or equal to 10 to the variable rv2
// Remark that since close is a sequence of data, when close>=10 is performed, the operation is performed in each period, so each period will have a return value of 1 and 0
rv2:=Close>=10;
```
    - 1. inferior ou igual a<=
```
omitted here
```
    - 1. igual a=
```
A:=O=C;     // Determine whether the opening price is equal to the closing price.
```
    - 1. Não é igual a<>
```
1<>2       // To determine whether 1 is not equal to 2, the return value is 1 (true)
```
  - Operadores lógicos
    
    Valor de retorno: Tipo booleano, quertrue(1) oufalse(0).
    1. A lógica e&&, pode ser substituído porand, e os lados esquerdo e direito da ligação devem ser estabelecidos ao mesmo tempo.
```
// Determine whether cond_a, cond_b, cond_c are established at the same time
cond_a:=2>1;
cond_b:=4>3;
cond_c:=6>5;
cond_a && cond_b and cond_c;    // The return value is 1, established
```
    1. Lógico ou||, pode usarorpara substituir os lados esquerdo e direito do link ou, um lado é verdadeiro (verdadeiro), o todo é verdadeiro (valor de retorno verdadeiro).
```
cond_a:=1>2;
cond_b:=4>3;
cond_c:=5>6;
cond_a || cond_b or cond_c;    // The return value is 1, established
```
    1. ()Operador, a expressão entre parênteses será avaliada primeiro.
```
1>2 AND (2>3 OR 3<5)    // The result of the operation is false
1>2 AND 2>3 OR 3<5      // The result of the operation is true
```
  - Operadores aritméticos
```
Return value: numeric type
```
    Operadores aritméticos são operadores aritméticos. É um símbolo para completar operações aritméticas básicas (operadores aritméticos), que é um símbolo usado para processar quatro operações aritméticas.
    - mais +
```
A:=1+1;      // return 2
```
    - menos -
```
A:=2-1;      // return 1
```
    - *multiplicar *
```
A:=2*2;      // return 4
```
    - Dividir
```
A:=4/2;      // return 2
```
- Funções
  - Funções
    
    No mundo da programação, uma função é um pedaço de código que implementa uma determinada função.
```
function(param1,param2,...)
```
    - Composição:
      
      O nome da função (parâmetro1, parâmetro2,...), pode não ter parâmetros ou ter vários parâmetros.MA(x,n);significa voltar para a média móvel simples dexdentronEntre eles,MA()é uma função,xensão os parâmetros da função.
      
      Quando usamos uma função, precisamos entender a definição básica da função, ou seja, quais dados podem ser obtidos chamando a função. Em geral, as funções têm parâmetros. Quando passamos parâmetros, precisamos garantir que o tipo de dados recebidos seja consistente. Nesta fase, a função de sugestão de código da maioria dos IDE é muito imperfeita. Há um tipo de dados do parâmetro dado, o que traz algum problema para nosso uso, eMA(x,n);é interpretada como:
```
Return to simple moving average
Usage:
AVG:=MA(X,N): N-day simple moving average of X, algorithm (X1+X2+X3+...+Xn)/N, N supports variables
```
      Isto é muito hostil para iniciantes, mas a seguir, vamos dissecar a função completamente, tentando encontrar uma maneira rápida de aprender e usar a função.
  - Valor de retorno
    
    Para aprender funções rapidamente, precisamos entender um conceito primeiro, é chamado valor de retorno, Regresso, como o nome sugere, significa retorno de volta; O valor representa valor específico, então o significado do valor de retorno é: os dados que podem ser obtidos.
```
// Because it will be used in the following code, the variable return_value is used to receive and save the return value of function()
// retrun_value := function(param1,param2);
// For example:
AVG:=MA(C,10);     // AVG is retrun_value, function is MA function, param1 parameter: C is the closing price sequence data, param2 parameter: 10.
```
  - Parâmetros
    
    Em segundo lugar, o segundo conceito importante da função é o parâmetro, e diferentes valores de retorno podem ser obtidos passando em diferentes parâmetros.
```
// The variable ma5 receives the 5-day moving average of closing prices
ma5:=MA(C,5);
// The variable ma10 receives the 10-day moving average of closing prices
ma10:=MA(C,10);
```
    O primeiro parâmetroXdas variáveis acima referidasma5, ma10éC(preço de encerramento), de facto,CA função 5 é também uma função (retorna a sequência de preços de fechamento desde a abertura até o presente), mas não tem parâmetros.MA()A função torna-se mais flexível para usar através dos parâmetros.
  - Como aprender
    - 1. Primeiro, precisamos entender o que uma função faz, ou seja, que dados essa função pode nos devolver.
    - 1. A última coisa é entender o tipo do valor de retorno.
    - 1. Além disso, precisamos saber o tipo de dados do parâmetroMA(x,n), se não conhecer o tipo de dados do parâmetrox, n, não será capaz de obter o valor de retorno corretamente.
    Na seguinte introdução e utilização da função, siga os três princípios acima.
- Melhoria da linguagem
  - MyLanguageeJavaScriptProgramação mista de idiomas
```
%%
// This can call any API quantified of FMZ
scope.TEST = function(obj) {
    return obj.val * 100;
}
%%
Closing price: C;
Closing price magnified 100 times: TEST(C);
The last closing price is magnified by 100 times: TEST(REF(C, 1)); // When the mouse moves to the K-line of the backtest, the variable value will be prompted
```
    - scopeObjeto
      
      OscopeO objeto pode adicionar atributos e atribuir funções anônimas aos atributos, e a função anônima referenciada por este atributo pode ser chamada na parte de código do MyLanguage.
    - scope.getRefs(obj)função
      
      EmJavaScriptBloco de código, liga para oscope.getRefs(obj)função para devolver os dados do passado emobj object.
      
      OJavaScriptCódigo embalado com o seguinte:%% %%vai receber oCA Comissão adoptou emTEST(C)função no código MyLanguage é chamado de preço de fechamento. Oscope.getRefsA função irá retornar todos os preços de fechamento destes dados K-line.throw "stop"para interromper o programa, a variávelarrcontém o preço de fechamento da primeira barra apenas.throw "stop", executará oreturnNo final doJavaScriptcódigo e devolver todos os dados de preço de fechamento.
```
%%
scope.TEST = function(obj){
    var arr = scope.getRefs(obj)
    Log("arr:", arr)
    throw "stop"
    return
}
%%
TEST(C);
```
    - scope.bars
      
      Aceder a todas as barras de linha K noJavaScriptBloco de código.
      
      OTEST1 é uma reta negativa e 0 é uma reta positiva.
```
%%
scope.TEST = function(){
    var bars = scope.bars
    return bars[bars.length - 1].Open > bars[bars.length - 1].Close ? 1 : 0    // Only numeric values can be returned
}
%%
arr:TEST;                                                                      
```
```
# Attention:
# An anonymous function received by TEST, the return value must be a numeric value.
# If the anonymous function has no parameters, it will result in an error when calling TEST, writing VAR:=TEST; and writing VAR:=TEST(); directly.
# TEST in scope.TEST must be uppercase.
```
    - scope.bar
      
      EmJavaScriptBloco de código, acede à barra de corrente.
      
      Calcular a média dos preços de abertura e de fechamento altos e baixos.
```
%%
scope.TEST = function(){
    var bar = scope.bar
    var ret = (bar.Open + bar.Close + bar.High + bar.Low) / 4
    return ret
}
%%
avg^^TEST;
```
    - scope.depth
      
      Acesso aos dados de profundidade do mercado (livro de encomendas).
```
%%
scope.TEST = function(){
    Log(scope.depth)
    throw "stop"             // After printing the depth data once, throw an exception and pause
}
%%
TEST;
```
    - scope.symbol
      
      Obter a cadeia de nomes do par de negociação atual.
```
%%
scope.TEST = function(){
    Log(scope.symbol)
    throw "stop"
}
%%
TEST;
```
    - scope.barPos
      
      Obter a posição Bar da linha K.
```
%%
scope.TEST = function(){
    Log(scope.barPos)
    throw "stop"
}
%%
TEST;
```
    - scope.get_locals (nome)
      
      Esta função é usada para obter as variáveis na seção de código do MyLanguage.
```
V:10;
%%
scope.TEST = function(obj){
    return scope.get_locals('V')
}
%%
GET_V:TEST(C);
```
```
# Attention:
# If a variable cannot calculate the data due to insufficient periods, call the scope.get_locals function in the JavaScript code at this time
# When getting this variable, an error will be reported: line:XX - undefined locals A variable name is undefined
```
    - scope.canTrade
      
      OcanTradeMarcas de atributo se a barra atual pode ser negociada (se a barra atual é a última)
      
      Por exemplo, julgar que os dados de mercado são impressos quando a estratégia está num estado em que a ordem pode ser negociada
```
%%
scope.LOGTICKER = function() {
    if(exchange.IO("status") && scope.canTrade){
        var ticker = exchange.GetTicker();
        if(ticker){
            Log("ticker:", ticker);
            return ticker.Last;
        }
    }
}
%%
LASTPRICE..LOGTICKER;
```
  - Exemplo de aplicação:
```
%%
scope.TEST = function(a){
    if (a.val) {
        throw "stop"
    }    
}
%%
O>C,BK;
C>O,SP;
TEST(ISLASTSP);
```
    Parar a estratégia após abrir e fechar uma posição uma vez.
- Referência para vários períodos
  
  O sistema selecionará automaticamente um período de linha K subjacente adequado e utilizará esses dados de período de linha K subjacentes para sintetizar todos os dados de linha K referenciados para garantir a precisão dos dados.
  - Utilização:#EXPORT formula_name ... #ENDSe a fórmula não é calculada apenas para obter dados de diferentes períodos, você também pode escrever uma fórmula vazia.
    
    Uma fórmula vazia é:
```
#EXPORT TEST 
NOP;
#END           // end
```
  - Utilização:#IMPORT [MIN,period,formula name] AS variable valueObter vários dados do período definido (preço de encerramento, preço de abertura, etc., obtidos por valor variável).
    
    OMINemIMPORTComando significaNível de minuto.MyLanguage da plataforma FMZ Quant, e apenas oMINO nível deIMPORTPeríodos não padrão são agora suportados.#IMPORT [MIN, 240, TEST] AS VAR240para importar dados, tais como a linha K de período de 240 minutos (4 horas).
    
    Exemplo de código:
```
// This code demonstrates how to reference formulas of different periods in the same code
// #EXPORT extended grammar, ending with #END marked as a formula, you can declare multiple
#EXPORT TEST 
Mean value 1: EMA(C, 20);
Mean value 2: EMA(C, 10);
#END // end

#IMPORT [MIN,15,TEST] AS VAR15 // Quoting the formula, the K-line period takes 15 minutes
#IMPORT [MIN,30,TEST] AS VAR30 // Quoting the formula, the K-line period takes 30 minutes
CROSSUP(VAR15.Mean value is 1, VAR30.Mean value is 1),BPK;
CROSSDOWN(VAR15.Mean value is 2, VAR30.Mean value is 2),SPK;
The highest price in fifteen minutes:VAR15.HIGH;
The highest price in thirty minutes:VAR30.HIGH;
AUTOFILTER;
```
  - É necessário prestar atenção ao utilizarREF, LLV, HHVe outras instruções para fazer referência a dados quando se fazem referência a dados em períodos múltiplos.
```
(*backtest
start: 2021-08-05 00:00:00
end: 2021-08-05 00:15:00
period: 1m
basePeriod: 1m
exchanges: [{"eid":"Futures_OKCoin","currency":"ETH_USD"}]
args: [["TradeAmount",100,126961],["ContractType","swap",126961]]
*)      

%%
scope.PRINTTIME = function() {
    var bars = scope.bars;
    return _D(bars[bars.length - 1].Time);
}
%%
BARTIME:PRINTTIME;      

#EXPORT TEST 
REF1C:REF(C,1);
REF1L:REF(L,1);
#END // end      

#IMPORT [MIN,5,TEST] AS MIN5
INFO(1, 'C:', C, 'MIN5.REF1C:', MIN5.REF1C, 'REF(MIN5.C, 1):', REF(MIN5.C, 1), 'Trigger BAR time:', BARTIME, '#FF0000');
INFO(1, 'L:', L, 'MIN5.REF1L:', MIN5.REF1L, 'REF(MIN5.L, 1):', REF(MIN5.L, 1), 'Trigger BAR time:', BARTIME, '#32CD32');
AUTOFILTER;
```
    Comparando a diferença entreMIN5.REF1CeREF(MIN5.C, 1), podemos encontrar:MIN5.REF1Cé o valor do preço de fechamento do penúltimo BAR no momento atual dos dados da linha K de 5 minutos.REF(MIN5.C, 1)é o período de linha K do modelo atual (o período de backtest do código acima é definido em 1 minuto, ou seja, ```period: 1m``), o preço de encerramento do período de 5 minutos em que o penúltimo BAR está localizado no momento atual. Estas duas definições são diferenciadas e podem ser utilizadas conforme necessário.
- Descrição do modo
  - Modelo de filtragem de sinal com uma abertura e um nivelamento
    
    No modelo, oAUTOFILTERQuando existem vários sinais de abertura que atendem às condições, o primeiro sinal é tomado como o sinal válido, e o mesmo sinal na linha K será filtrado.
    
    Instruções suportadas pelo modelo de filtragem: BK, BP, BPK, SK, SP, SPK, CLOSEOUT, etc. Não são suportadas instruções com números de lote, como BK ((5).
    
    Por exemplo:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(C,MA1),BK;
CROSSUP(MA1,MA2),BK;
C>BKPRICE+10||C<BKPRICE-5,SP;
AUTOFILTER;
```
```
Comprehension:
As in the above example, when AUTOFILTER is not set, the third row BK, the fourth row BK and the fifth row SP are triggered in sequence, and each K-line triggers a signal once. After opening the position, and closing the position, the model state is reset.      
If AUTOFILTER is set, after triggering BK, only SP is triggered, other BK signals are ignored, and each K-line triggers a signal once.
```
  - Modelo de posição de aumento e de diminuição
    
    OAUTOFILTERA função não está escrita no modelo, permitindo sinais de abertura contínua ou sinais de fechamento contínuos, que podem aumentar e diminuir as posições.
    
    Instruções suportadas: BK(N), BP(N), SK(N), SP(N), CLOSEOUT, BPK(N), SPK(N), as ordens de abertura e fechamento sem tamanho de lote não são suportadas. (1) É aceite o agrupamento de instruções. (2) Quando se cumprem simultaneamente várias condições de instrução, os sinais são executados na ordem em que as instruções condicionais são escritas. Por exemplo:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(C,MA1),BK(1);
CROSSUP(MA1,MA2),BK(1);
C>BKPRICE+10||C<BKPRICE-5,SP(BKVOL);
```
    UtilizaçãoTRADE\_AGAINÉ possível fazer a mesma linha de comando, vários sinais em sucessão.
```
Comprehension:
The above example is executed one by one, and the signal after execution is no longer triggered. Reset the model status after closing the position. A K -line triggers a signal once.
```
  - Modelo com uma linha K e um sinal
    
    Independentemente de a linha K estar terminada, o sinal é calculado em ordens em tempo real, ou seja, a linha K é colocada antes da ordem ser concluída; a linha K é revisada no final.
    
    Por exemplo:
```
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(MA1,MA2),BPK;    //The 5-period moving average crosses up, and the 10-period moving average goes long.
CROSSDOWN(MA1,MA2),SPK;  //The 5-period moving average crosses down, and the 10-period moving average goes short.
AUTOFILTER;
```
  - Um modelo de sinais múltiplos em uma linha K
    
    O modelo utilizamultsigPara controlar e implementar múltiplos sinais de uma linha K.
    
    Independentemente da conclusão da linha K, o sinal é calculado em tempo real.
    
    O sinal não é revisto, não há desaparecimento de sinal e a direção do sinal é sempre consistente com a direção da posição.
    
    Se várias condições de sinal forem atendidas em uma linha K, ela pode ser executada repetidamente.
```
For example:
MA1:MA(CLOSE,5);
MA2:MA(CLOSE,10);
CROSSUP(MA1,MA2),BK;
C>BKPRICE+10||C<BKPRICE-5,SP;
AUTOFILTER;
MULTSIG(0,0,2,0);
```
    MULTSIGPode executar várias linhas de comando dentro de uma linha K. Uma linha de comando só é sinalizada uma vez.
```
O<C,BK;            // These conditions may all be executed in a K-line Bar, but only one signal per line
10+O<C,BK;         // Strategy plus TRADE_AGAIN(10);it can make multiple signals per line
20+O<C,BK;
40+O<C,BK;
MULTSIG(1,1,10);
```
    Suplemento: 1.O modelo de adição e redução de posições, de duas formas, de um sinal e de uma linha K: a colocação de uma ordem ao preço de encerramento e a colocação de uma ordem ao preço da ordem, são ambos suportados. 2.O modelo de adição e redução de posições suporta também a ordenação de múltiplos sinais a partir de uma linha K. O modelo de adição e redução de posições, escrever omultsigfunção para realizar múltiplas adições ou múltiplas reduções em uma linha K.
- Modo de execução
  - Modelo de barra
    
    O modelo Bar refere-se ao modelo que é executado após a conclusão do BAR atual e a negociação é executada quando o próximo BAR começa.
  - Modelo de carrapato
    
    O modelo Tick significa que o modelo é executado uma vez para cada movimento de preço e é negociado imediatamente quando há um sinal. O modelo Tick ignora o sinal do dia anterior (o sinal do dia anterior é executado imediatamente no mesmo dia), e o modelo Tick concentra-se apenas nos dados do mercado atual para determinar se o sinal é acionado.
- Exibição de gráfico
  - Indicadores adicionais para o gráfico principal
    
    Utilize o operador^^, os indicadores definidos são exibidos no gráfico principal enquanto se atribuem valores às variáveis.
```
MA60^^MA(C, 60);  // Calculate the average indicator with the parameter of 60
```
  - Indicadores adicionais para o sub-gráfico
    
    Utilize o operador:, os indicadores definidos são exibidos no sub-gráfico enquanto se atribuem valores às variáveis.
```
ATR:MA(MAX(MAX((HIGH-LOW),ABS(REF(CLOSE,1)-HIGH)),ABS(REF(CLOSE,1)-LOW)),26);    // Assign a value to the ATR variable, the ":" symbol is followed by the formula for calculating the ATR
```
    Se não quiser que seja exibido no gráfico principal ou no subgráfico, utilize o operador ....
```
MA60..MA(C, 60);  // Calculate the average indicator with the parameter of 60
```
    Pode usarDOTeCOLORREDpara definir o tipo de linha e a cor da linha, etc., em linha com os hábitos dos utilizadores familiarizados com o MyLanguage.
- Problemas comuns
  
  Introduzir oProblemasOs indicadores de desempenho são os pontos mais frequentemente encontrados no processo de elaboração dos indicadores, geralmente os pontos que devem ser considerados na elaboração dos indicadores de desempenho (continuamente adicionados).
  - Observe o ponto e vírgula;no final.
  - Observe que as palavras-chave do sistema não podem ser declaradas como variáveis.
  - Observe que a string usaCitações únicas, por exemplo: a cadeia'Open position'.
  - Observação
    
    Annotação
    - // The Remark content(método de entrada pode ser digitado em chinês e inglês) significa que o código não é compilado durante o processo de execução, ou seja, o conteúdo após//Normalmente usamo-lo para marcar o significado do código, quando é conveniente para revisão de código, ele pode ser rapidamente compreendido e lembrado.
    - { Remark content }Observação de bloqueio.
```
A:=MA(C,10);
{The previous line of code is to calculate the moving average.}
```
    - (* Remark content *)Observação de bloqueio.
```
A:=MA(C,10);
(*The previous line of code is to calculate the moving average.*)
```
  - Input
    
    Quando se escreve código, porque o método de entrada é muitas vezes alternado entre chinês e inglês, resultando em erros de símbolos.:Terminador.;, vírgula,, parênteses()Estes caracteres em diferentes estados de chinês e inglês precisam de atenção.
    
    Se você usar Sogou, Baidu, ou Bing métodos de entrada, você pode mudar rapidamente entre chinês e inglês pressionando oshiftUma vez.
  - Lógica propensa a erros
    1. Pelo menos, não menos que, não menos que: o operador relacional correspondente>=.
    2. Até, no máximo: o operador relacional correspondente<=.
  - Sincronização de lançamento de estratégia
    
    Na estratégia de futuros, se houver uma posição aberta manualmente antes do robô de estratégia começar, quando o robô começar, ele irá detectar a informação de posição e sincronizá-lo com o estado da posição real. Na estratégia, pode utilizar oSP, BP, CLOSEOUTcomandos para fechar a posição.
```
%%
if (!scope.init) {
    var ticker = exchange.GetTicker();
    exchange.Buy(ticker.Sell+10, 1);
    scope.init = true;
}
%%
C>0, CLOSEOUT;
```
  - Posições bidirecionais não suportadas
    
    O MyLanguage não suporta o mesmo contrato com posições longas e curtas.

Citação de dados de linha K

Abertura

Obtenha o preço de abertura do gráfico da linha K.

Preço inicial

Função: OPEN, abreviação de O

Parâmetros: nenhum

Explicação: Retorna o preço de abertura de este período

Dados de sequência

OPEN gets the opening price of the K-line chart.

Remark:
1.It can be abbreviated as O.

Example 1:
OO:=O;           //Define OO as the opening price; Remark that the difference between O and 0.
Example 2:
NN:=BARSLAST(DATE<>REF(DATE,1));
OO:=REF(O,NN);   //Take the opening price of the day
Example 3:
MA5:=MA(O,5);    //Define the 5-period moving average of the opening price (O is short for OPEN).

Altíssimo

Obtenha o preço mais alto no gráfico da linha K.

O preço mais alto

Função: HIGH, abreviado H

Parâmetros: nenhum

Explicação: Retorna o preço mais elevado do este período

Dados de sequência

HIGH achieved the highest price on the K-line chart.

Remark:
1.It can be abbreviated as H.

Example 1:
HH:=H;         // Define HH as the highest price
Example 2:
HH:=HHV(H,5);  // Take the maximum value of the highest price in 5 periods
Example 3:
REF(H,1);      // Take the highest price of the previous K-line

Baixo

Arranja o preço mais baixo no gráfico da linha K.

O preço mais baixo

Função: LOW, abreviada L

Parâmetros: nenhum

Explicação: Retorna o preço mais baixo do este período

Dados de sequência

LOW gets the lowest price on the K-line chart.

Remark:
1.It can be abbreviated as L.

Example 1:
LL:=L;            // Define LL as the lowest price
Example 2:
LL:=LLV(L,5);     // Get the minimum value of the lowest price in 5 periods
Example 3:
REF(L,1);         // Get the lowest price of the previous K-line

- Não.

Obtenha o preço de fechamento do gráfico da linha K.

Preço de encerramento

Função: CLOSE, abreviada como C

Parâmetros: nenhum

Explicação: Retorna o preço de encerramento de este período

Dados de sequência

CLOSE Get the closing price of the K-line chart

Remarks:
1.Obtain the latest price when the intraday K-line has not finished.
2.It can be abbreviated as C.

Example 1:
A:=CLOSE;          //Define the variable A as the closing price (A is the latest price when the intraday K-line has not finished)
Example 2:
MA5:=MA(C,5);      //Define the 5-period moving average of the closing price (C is short for CLOSE)
Example 3:
A:=REF(C,1);       //Get the closing price of the previous K-line

VOL

Obter o volume de negociação do gráfico de linha K.

Volume de negociação

Função: VOL, abreviada como V

Parâmetros: nenhum

Explicação: Retorna o volume de negociação de este período

Dados de sequência

VOL obtains the trading volume of the K-line chart.

Remarks:
 It can be abbreviated as V.
The return value of this function on the current TICK is the cumulative value of all TICK trading volume on that day.

Example 1:
VV:=V;       // Define VV as the trading volume
Example 2:
REF(V,1);    // Indicates the trading volume of the previous period
Example 3:
V>=REF(V,1); // The trading volume is greater than the trading volume of the previous period, indicating that the trading volume has increased (V is the abbreviation of VOL)

OPI

Tomar a posição total atual no mercado de futuros (contratos).
```
OpenInterest:OPI;
```

REF

Citação.

Reference the value of X before N periods.

Remarks:
1.When N is a valid value, but the current number of K-lines is less than N, returns null;
2.Return the current X value when N is 0;
3.Return a null value when N is null.
4.N can be a variable.

Example 1:
REF(CLOSE,5);Indicate the closing price of the 5th period before the current period is referenced
Example 2:
AA:=IFELSE(BARSBK>=1,REF(C,BARSBK),C);//Take the closing price of the K-line of the latest position opening signal
// 1）When the BK signal is sent, the bar BARSBK returns null, then the current K-line REF(C, BARSBK) that sends out the BK signal returns null;
// 2）When the BK signal is sent out, the K-line BARSBK returns null, and if BARSBK>=1 is not satisfied, it is the closing price of the K-line.
// 3）The K-line BARSBK after the BK signal is sent, returns the number of periods from the current K-line between the K-line for purchasing and opening a position, REF(C,BARSBK)
Return the closing price of the opening K-line.
// 4）Example: three K-lines: 1, 2, and 3, 1 K-line is the current K-line of the position opening signal, then returns the closing price of the current K-line, 2, 3
The K-line returns the closing price of the 1 K-line.

UNIT

Arranja a unidade de negociação do contrato de dados.

Get the trading unit of the data contract.
Usage:
UNIT takes the trading unit of the loaded data contract.

Valor nominal da moeda

O valor UNIT é 1.

Futuros de criptomoedas

O valor UNIT está relacionado com a moeda do contrato.

OKEX futures currency standard contracts: 1 contract for BTC represents $100, 1 contract for other currencies represents $10

MINPRICE

O preço mínimo de variação do contrato de dados.

Take the minimum variation price of the data contract.
Usage:
MINPRICE; Take the minimum variation price of the loaded data contract.

MinPRICE1

O preço mínimo de variação de um contrato de negociação.

Take the minimum variation price of a trading contract.
Usage:
MINPRICE1; Take the minimum variation price of a trading contract.

Função de tempo

BARPOS

Assuma a posição da linha K.

BARPOS, Returns the number of periods from the first K-line to the current one.

Remarks:
1.BARPOS returns the number of locally available K-line, counting from the data that exists on the local machine.
2.The return value of the first K-line existing in this machine is 1.

Example 1:LLV(L,BARPOS);        // Find the minimum value of locally available data.

Example 2:IFELSE(BARPOS=1,H,0); // The current K-line is the first K-line that already exists in this machine, and it takes the highest value, otherwise it takes 0.

DAYBARPOS

DAYBARPOS o atual K-line BAR é o K-line BAR do dia.
Período

O valor do período é o número de minutos.
```
1, 3, 5, 15, 30, 60, 1440
```

Data

DataFunção DATE, Obter o ano, mês e dia do período desde 1900.

Example 1:
AA..DATE;                  // The value of AA at the time of testing is 220218, which means February 18, 2022

Tempo

Está na hora de fazer a linha K.

TIME, the time of taking the K-line.

Remarks:
1.The function returns in real time in the intraday, and returns the starting time of the K-line after the K-line is completed.
2.This function returns the exchange data reception time, which is the exchange time.
3.The TIME function returns a six-digit form when used on a second period, namely: HHMMSS, and displays a four-digit form on other periods, namely: HHMM.
4.The TIME function can only be loaded in periods less than the daily period, and the return value of the function is always 1500 in the daily period and periods above the daily period.
5. It requires attention when use the TIME function to close a position at the end of the day
(1).It is recommended to set the time for closing positions at the end of the market to the time that can actually be obtained from the return value of the K-line (for example: the return time of the last K-line in the 5-minute period of the thread index is 1455, and the closing time at the end of the market is set to TIME>=1458, CLOSEOUT; the signal of closing the position at the end of the market cannot appear in the effect test)
(2).If the TIME function is used as the condition for closing the position at the end of the day, it is recommended that the opening conditions should also have a corresponding time limit (for example, if the condition for closing the position at the end of the day is set to TIME>=1458, CLOSEOUT; then the condition TIME needs to be added to the corresponding opening conditions. <1458; avoid re-opening after closing)

Example 1:
C>O&&TIME<1450,BK;
C<O&&TIME<1450,SK;
TIME>=1450,SP;
TIME>=1450,BP;
AUTOFILTER;
// Close the position after 14:50.
Example 2:
ISLASTSK=0&&C>O&&TIME>=0915,SK;

ANO

Year.

YEAR, year of acquisition.

Remark:
The value range of YEAR is 1970-2033.

Example 1:
N:=BARSLAST(YEAR<>REF(YEAR,1))+1;
HH:=REF(HHV(H,N),N);
LL:=REF(LLV(L,N),N);
OO:=REF(VALUEWHEN(N=1,O),N);
CC:=REF(C,N);                               // Take the highest price, lowest price, opening price, and closing price of the previous year
Example 2:
NN:=IFELSE(YEAR>=2000 AND MONTH>=1,0,1);

Mês

Leva o mês.

MONTH, returns the month of a period.

Remark:
The value range of MONTH is 1-12.

Example 1:
VALUEWHEN(MONTH=3&&DAY=1,C);                // Take its closing price when the K-line date is March 1
Example 2:
C>=VALUEWHEN(MONTH<REF(MONTH,1),O),SP;

Dia

Obter o número de dias em um período

DAY, returns the number of days in a period.

Remark:
The value range of DAY is 1-31.

Example 1:
DAY=3&&TIME=0915，BK;                      // 3 days from the same day, at 9:15, buy it
Example 2:
N:=BARSLAST(DATE<>REF(DATE,1))+1;
CC:=IFELSE(DAY=1,VALUEWHEN(N=1,O),0);      // When the date is 1, the opening price is taken, otherwise the value is 0

Horário

Hour.

HOUR, returns the number of hours in a period.

Remark:
The value range of HOUR is 0-23

Example 1:
HOUR=10;                                   // The return value is 1 on the K-line at 10:00, and the return value on the remaining K-lines is 0

Minuto

Minute.

MINUTE, returns the number of minutes in a period.

Remarks:
1: The value range of MINUTE is 0-59
2: This function can only be loaded in the minute period, and returns the number of minutes when the K-line starts.
Example 1:
MINUTE=0;                                 // The return value of the minute K-line at the hour is 1, and the return value of the other K-lines is 0
Example 2:
TIME>1400&&MINUTE=50,SP;                   // Sell and close the position at 14:50

Dia da Semana

Arranja o número da semana.

WEEKDAY, get the number of the week.

Remark:
1: The value range of WEEKDAY is 0-6. (Sunday ~ Saturday)

Example 1:
N:=BARSLAST(MONTH<>REF(MONTH,1))+1;
COUNT(WEEKDAY=5,N)=3&&TIME>=1450,BP;
COUNT(WEEKDAY=5,N)=3&&TIME>=1450,SP;
AUTOFILTER;                               // Automatically close positions at the end of the monthly delivery day
Example 2:
C>VALUEWHEN(WEEKDAY<REF(WEEKDAY,1),O)+10,BK;
AUTOFILTER;

Função de julgamento lógico

BARSTATUS

Devolver o estado da posição para o período em curso.

BARSTATUS returns the position status for the current period.

Remark:
The function returns 1 to indicate that the current period is the first period, returns 2 to indicate that it is the last period, and returns 0 to indicate that the current period is in the middle.

Example:
A:=IFELSE(BARSTATUS=1,H,0);              // If the current K-line is the first period, variable A returns the highest value of the K-line, otherwise it takes 0

Entre

Between.

BETWEEN(X,Y,Z) indicates whether X is between Y and Z, returns 1 (Yes) if established, otherwise returns 0 (No).

Remark:
1.The function returns 1(Yse) if X=Y, X=Z, or X=Y and Y=Z.

Example 1:
BETWEEN(CLOSE,MA5,MA10);                // It indicates that the closing price is between the 5-day moving average and the 10-day moving average

BARSLASTCOUNT

BARSLASTCOUNT(COND) conta o número de períodos consecutivos que satisfazem a condição, contando para a frente a partir do período atual.

Remark:
1. The return value is the number of consecutive non zero periods calculated from the current period
2. the first time the condition is established when the return value of the current K-line BARSLASTCOUNT(COND) is 1

Example:
BARSLASTCOUNT(CLOSE>OPEN);
//Calculate the number of consecutive positive periods within the current K-line

CROSS

Função cruzada.

CROSS(A,B) means that A crosses B from bottom to top, and returns 1 (Yes) if established, otherwise returns 0 (No)

Remark:
1.To meet the conditions for crossing, the previous k-line must satisfy A<=B, and when the current K-line satisfies A>B, it is considered to be crossing.

Example 1:
CROSS(CLOSE,MA(CLOSE,5));              // Indicates that the closing line crosses the 5-period moving average from below

O que é o nome do produto?

Crossdown

CROSSDOWN(A,B): indicates that when A passes through B from top to bottom, it returns 1 (Yes) if it is established, otherwise it returns 0 (No)

Remark:
1.CROSSDOWN(A,B) is equivalent to CROSS(B,A), and CROSSDOWN(A,B) is easier to understand

Example 1:
MA5:=MA(C,5);
MA10:=MA(C,10);
CROSSDOWN(MA5,MA10),SK;               // MA5 crosses down MA10 to sell and open a position
// CROSSDOWN(MA5,MA10),SK; Same meaning as CROSSDOWN(MA5,MA10)=1,SK;

CROSSUP

Crossup.

CROSSUP(A,B) means that when A crosses B from the bottom up, it returns 1 (Yes) if it is established, otherwise it returns 0 (No)

Remark:
1.CROSSUP(A,B) is equivalent to CROSS(A,B), and CROSSUP(A,B) is easier to understand.

Example 1:
MA5:=MA(C,5);
MA10:=MA(C,10);
CROSSUP(MA5,MA10),BK;                 // MA5 crosses MA10, buy open positions
// CROSSUP(MA5,MA10),BK;与CROSSUP(MA5,MA10)=1,BK; express the same meaning

Todos.

Determinar se está continuamente satisfeito.

EVERY(COND,N), Determine whether the COND condition is always satisfied within N periods. The return value of the function is 1 if it is satisfied, and 0 if it is not satisfied.

Remarks:
1.N contains the current K-line.
2.If N is a valid value, but there are not so many K-lines in front, or N is a null value, it means that the condition is not satisfied, and the function returns a value of 0.
3.N can be a variable.

Example 1:
EVERY(CLOSE>OPEN,5);                // Indicates that it has been a positive line for 5 periods
Example 2:
MA5:=MA(C,5);                       // Define a 5-period moving average
MA10:=MA(C,10);                     // Define a 10-period moving average
EVERY(MA5>MA10,4),BK;               // If MA5 is greater than MA10 within 4 periods, then buy the open position
// EVERY(MA5>MA10,4),BK; has the same meaning as EVERY(MA5>MA10,4)=1,BK;

EXISTEM

Determine se há satisfação.

EXIST(COND, N) judges whether there is a condition that satisfies COND within N periods.

Remarks:
1.N contains the current K-line.
2.N can be a variable.
3.If N is a valid value, but there are not so many K-lines in front, it is calculated according to the actual number of periods.

Example 1:
EXIST(CLOSE>REF(HIGH,1),10);     // Indicates whether there is a closing price greater than the highest price of the previous period in 10 periods, returns 1 if it exists, and returns 0 if it does not exist
Example 2:
N:=BARSLAST(DATE<>REF(DATE,1))+1;
EXIST(C>MA(C,5),N);              // Indicates whether there is a K-line that satisfies the closing price greater than the 5-period moving average on the day, returns 1 if it exists, returns 0 if it does not exist

Se

Função de condição.

IF(COND,A,B)Returns A if the COND condition is true, otherwise returns B.

Remarks:
1.COND is a judgment condition; A and B can be conditions or values.
2.This function supports the variable circular reference to the previous period's own variable, that is, supports the following writing Y: IF(CON,X,REF(Y,1)).
Example 1:
IF(ISUP,H,L);                   // The K-line is the positive line, the highest price is taken, otherwise the lowest price is taken
Example 2:
A:=IF(MA5>MA10,CROSS(DIFF,DEA),IF(CROSS(D,K),2,0));     // When MA5>MA10, check whether it satisfies the DIFF and pass through DEA, otherwise (MA5 is not greater than MA10), when K and D are dead fork, let A be assigned a value of 2, if none of the above conditions are met, A is assigned a value of 0
A=1,BPK;                                                // When MA5>MA10, the condition for opening a long position is to cross DEA above the DIFF
A=2,SPK;                                                // When MA5 is not greater than MA10, use K and D dead forks as the conditions for opening short positions

IFELSE

Função de condição.

IFELSE(COND,A,B) Returns A if the COND condition is true, otherwise returns B.

Remarks:
1.COND is a judgment condition; A and B can be conditions or values.
2.This function supports variable circular reference to the previous period's own variable, that is, supports the following writing Y: IFELSE(CON,X,REF(Y,1));
Example 1:
IFELSE(ISUP,H,L);                                             // The K-line is the positive line, the highest price is taken, otherwise the lowest price is taken
Example 2:
A:=IFELSE(MA5>MA10,CROSS(DIFF,DEA),IFELSE(CROSS(D,K),2,0));   // When MA5>MA10, check whether it satisfies the DIFF and pass through DEA, otherwise (MA5 is not greater than MA10), when K and D are dead fork, let A be assigned a value of 2, if none of the above conditions are met, A is assigned a value of 0
A=1,BPK;                                                      // When MA5>MA10, the condition for opening a long position is to cross DEA above the DIFF
A=2,SPK;                                                      // When MA5 is not greater than MA10, use K and D dead forks as the conditio

Próxima página

Relacionados

Mais.

Doc MyLanguage

Instruções básicas

Contrato

Variaveis

Regras de nomeação

Tipo de dados

Operador

Operador de atribuição

Operadores relacionais

Operadores lógicos

Operadores aritméticos

Funções

Funções

Valor de retorno

Parâmetros

Como aprender

Melhoria da linguagem

Referência para vários períodos

Descrição do modo

Modelo de filtragem de sinal com uma abertura e um nivelamento

Modelo de posição de aumento e de diminuição

Modelo com uma linha K e um sinal

Um modelo de sinais múltiplos em uma linha K

Modo de execução

Modelo de barra

Modelo de carrapato

Exibição de gráfico

Indicadores adicionais para o gráfico principal

Indicadores adicionais para o sub-gráfico

Problemas comuns

Observação

Input

Lógica propensa a erros

Sincronização de lançamento de estratégia

Posições bidirecionais não suportadas