Problemas de fechamento, por favor, ajude - página 8
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Olá Cameofx,
Obrigado por sua amável resposta.
Este sistema de codificação é muito simples e fácil.
Tudo feito manualmente no MetaEditor.
De fato, o sistema está sendo projetado para desenvolver grandes programas facilmente e com alta velocidade.
O sistema também deve ser flexível e confiável.
Com os melhores cumprimentos!
Ais, obrigado por sua resposta. Aprendi muito com seus posts :)
Cameo
Olá amigos!
Uma coisa do passado paira sobre mim dia após dia.
Isto é documentação para a AIS5 Trade Machine.
Voltarei assim que Deus decidir.
Tchau por enquanto!
Olá, Ais
Sua ausência será muito sentida. Fique bem.
Agradecemos seu retorno.
Seu amigo, Saúde
Olá Ais
Parece que não consigo encontrar nenhuma resposta firme no livro ou fórum. Em um esquema de lógica de relé, um portão AND funcionaria da mesma forma que o exemplo acima. Somente quando há duas entradas "verdadeiras", haverá uma saída "verdadeira". Somente então, o controle continuará.Ao retornar, lamento sobrecarregá-lo imediatamente com mais perguntas. Não é o seu sistema em particular, eu tenho este problema com a maioria dos programas. Tem a ver com funções definidas pelo usuário. Como a função definida pelo usuário obtém a sua definição.
Por exemplo, como a função definida pelo usuário obtém a sua definição:
Aguardando sua resposta. Agradecemos antecipadamente.
Abraço
Olá Huckleberry
Vamos esclarecer esta parte do código.
1. Provavelmente grandes dificuldades:
1.1. Todos os humanos pensam e agem de forma diferente;
1.2. Eu gosto de usar um número estritamente limitado de tipos de dados;
1.3. Gosto de usar apenas tipos de dados "padrão":
1.3.1. "int",
1.3.2. "double",
1.3.3. "string";
1.4. Uso outros tipos de dados somente em casos especiais;
1.5. Denoto tipo dos elementos do meu programa por letra pequena na primeira posição dos nomes:
1.5.1. "i" para tipo de dados "int",
1.5.2. "d" para tipo de dados "double",
1.5.3. "s" para tipo de dados "string",
1.5.4. "r" para tipo de dados "indefinido";
1.6. esta técnica de programação me ajuda a controlar o tipo de fundição;
1.7. funções e constantes predefinidas também podem ter os seguintes tipos de dados:
1.7.1. "bool",
1.7.2. "color",
1.7.3. "datetime";
1.8. Estou sempre tentando lançar estes tipos para o tipo "int";
1.9. para hoje meus dados de fundição normalmente estão implícitos;
1.10. alguns elementos essenciais de minhas técnicas de programação:
1.10.1. Eu gostava de usar o par de constantes "TRUE" e "EMPTY" em vez do par de constantes "TRUE" e "FALSE";
1.10.2. em declarações "se" algumas vezes usei "1" e "0" em vez de "VERDADEIRO" e "FALSO";
1.10.3. Usei a constante "VAZIO" com valor negativo "-1" para denotar resultados inválidos para elementos de dados não assinados;
1.10.4. no futuro usarei o tipo "bool" com prefixo "b" nos nomes.
2. Temos que saber sobre os tipos de dados MQL4 a seguir:
2.1. "int" é um <!>signed</!> número inteiro longo de 4 bytes com valores de -2147483648 a 2147483647;
2.2. "datetime" é um <!>desassinado</!> número inteiro longo de 4 bytes com valores de 0 a 4294967295;
2.3. atribuindo valores de "datetime" às variáveis "int", obtemos resultados corretos até aproximadamente 2038.01.01.
3. Temos que saber sobre a função "iTime ( símbolo, cronograma, turno )" seguindo:
3.1. esta função sempre retorna um valor do tipo "datetime";
3.2. há 2 casos diferentes de retorno:
3.2.1. "0" se o histórico local estiver vazio;
3.2.2. tempo aberto para a barra indicada com "shift" em todos os outros casos;
3.3. "iTime ( 0, 0, 0 )" retorna o tempo aberto para a barra zero do gráfico atual;
3.4. enquanto a barra zero é a mesma, "iTime ( 0, 0, 0 )" retorna o mesmo valor;
3.5. quando a barra zero atual é completada, esta barra se torna a barra número 1 e a formação de nova barra zero é iniciada;
3.6. "iTime ( 0, 0, 0 )" retorna o novo valor;
3.7. assim, o valor do "iTime ( 0, 0, 0 )" é alterado quando a barra zero é alterada.
4. Impedimos o trabalho com histórico vazio no bloco de programa "2.2.3.1. Inspeção de histórico de dados".
5. Quando a ordem é fechada com sucesso na função "iTryClose" atribuímos "iTradeBarTime = iTime ( 0, 0, 0 ) ;".
6. Na função "iSignalOpen", inspecionamos se "iTradeBarTime == iTime ( 0, 0, 0 ) )".
7. Se for verdade e o comércio repetido for proibido pelo "iTradeBarOnce = 1 ;" então proibimos o sinal de abrir pelo valor "VAZIO".
Abraço
Olá, Ais
Obrigado por sua resposta. Estudarei sobre isto e voltarei em breve.
Abraço
Olá, Ais,
Desculpe pela minha resposta lenta. Comecei a trabalhar de novo em minha ocupação regular na segunda-feira. O tempo é um pouco mais curto hoje em dia. O tempo de estudo é mais curto.
Como mencionei anteriormente dentro desta linha, eu gosto de quebrar as coisas até as porcas e parafusos. Como uma roda dentada fornece energia a outra e assim por diante. Assim, descobri que o controle dentro do programa é fascinante. Por favor, entendam que eu respeito a todos vocês pela paciência e conhecimento que vocês proporcionaram, mas tenho dúvidas sobre a necessidade do bloco 2.2.3.1.
Como o iBaseLag + iBaseBar pode ser uma expressão?
Entendi que iBaseLag e iBaseBar estão dentro do parâmetro para iHighest e iLowest. A menos que sejam números explícitos,
como se pode determinar qual será o número exato. iBaseLag é 20, o que representa 20 barras utilizadas para o cálculo da média.
O iBaseBar representa em que barra a média deve começar. Barras de 1 a 20, neste caso, a barra zero não é considerada.
Tomei a liberdade de encurtar o programa em /* 2.2.3.1*/. Testei o programa e encontrei os mesmos resultados. Ao executar o programa em condições reais de comercialização, isto pode não ser uma boa idéia.
Qual é a sua opinião, por favor?
Além disso, sua explicação para o bloqueio 2.1.2 teve um esclarecimento para minha confusão. O iTime retorna o tempo aberto da barra zero.
O iTradeBarTime também é um tipo de data de lançamento. O programa sabe em que barra a troca foi feita, portanto apenas uma troca por barra... . iTradeBarOnce == 1
Obrigado
Estarei estudando mais nos próximos dias. Mas o bloco 2.1.1 reservered pode ser usado para uma função que proporcionaria posições adicionais às posições existentes. Exemplo: um longo já existente, e depois adicionar três ou mais longos?
Com as funções que já estão no programa, haveria conflitos com as posições adicionais?
Mais uma vez, obrigado por tudo. Fique bem
Abraço
Olá Huckleberry,
Vamos analisar cuidadosamente a parte principal do programa, incluindo o bloco 2.2.3.1:
////////////////////////////////////////////////////////////////////< 14> // < 2.2.3. Code : Special : Start > //< > int start () // - i 9 l - o //< > { //< > // < 2.2.3.1. History data inspection 4 >`````````````````````````//< > static int iTrigger = 0 ; if ( iTrigger == 0 ) { //< > if ( ( iTime ( 0 , 0 , 0 ) == 0 ) //< > || ( iBars ( 0 , 0 ) < iBaseLag + iBaseBar ) ) //< > return ; else iTrigger = 1 ; } //< > // </2.2.3.1. History data inspection 4 >`````````````````````````//< > // //< > // < 2.2.3.2. Main routine 3 >````````````````````````````````````//< > int iTicket = iGetTicket () ; //< > // //< > if ( iTicket < 0 ) iTryOpen () ; //< > else iTryClose () ; //< > // </2.2.3.2. Main routine 3 >````````````````````````````````````//< > // //< > // < 2.2.3.3. Exception handler 2 >```````````````````````````````//< > int iTrap = GetLastError () ; //< > if ( iTrap > 0 ) Alert ( "Exception " , iTrap ) ; //< > // </2.2.3.3. Exception handler 2 >```````````````````````````````//< > } //< > // </2.2.3. Code : Special : Start > //< > ////////////////////////////////////////////////////////////////////< 0>1. o bloco 2.2.3.1., o primeiro bloco do programa, é um gatilho simples:
1.1. "static int iTrigger" armazena valor próprio durante toda a vida útil do programa, tal como "static";
1.2. inicialmente "iTrigger == 0";
1.3. declaração "se ( iTrigger == 0 )" é executada em cada tick;
1.4. logo na primeira vez, quando "iTrigger == 0", a inspeção de dados do histórico é executada dentro do bloco {..};
1.5. se os dados do histórico estiverem incorretos, a instrução "return;" é executada;
1.6. significa que a execução da função principal "start ()" terminou;
1.7. no próximo tick statement "se ( iTrigger == 0 )" for executado novamente;
1.8. se os dados do histórico estiverem corretos, a instrução "iTrigger = 1 ;" for executada;
1.9. então a execução da função principal "start ()" continua;
1.10. na próxima declaração "se ( iTrigger == 0 )" for executado novamente;
1.11. o valor do "iTrigger" agora e no futuro será sempre "== 1" porque é estático;
1.12. assim, no histórico futuro a inspeção de dados será sempre pulada;
1.13. tal é o gatilho simples;
2. inspeção de dados do histórico consiste em duas partes:
2.1. verificar se o histórico local está vazio "iTime ( 0, 0, 0 ) == 0";
2.2. verificar se o tamanho do histórico local é suficiente para o cálculo do "iATR ( 0, 0, iBaseLag, iBaseBar )", onde:
2.2.1. "iBaseBar" é a barra inicial para "iATR";
2.2.2. "iBaseLag" é o número de barras de média para "iATR";
2.2.3. "iBaseLag + iBaseBar" é uma expressão usual, o resultado é sempre uma soma de "iBaseLag" e "iBaseBar";
2.2.4. em outras palavras, a expressão "iBaseLag + iBaseBar" é equivalente à soma de "iBaseLag" e "iBaseBar";
2.2.5. podemos atribuir qualquer valor para "iBaseLag" e "iBaseBar" na entrada do programa no bloco 1.1.1.;
2.2.6. vamos atribuir "iBaseLag = 100 ;" e "iBaseBar = 7 ;";
2.2.7. então o cálculo correto do "iATR ( 0, 0, iBaseLag, iBaseBar )" será possível, se o tamanho do histórico local for igual a 107 ou maior, porque o último número de barras para o cálculo é #106 e o número de barras zero é sempre considerado.
É possível adicionar qualquer número de funções em qualquer programa, o bloco 2.1.1 demonstra apenas uma amostra da possível implementação.
A provisão de posições adicionais exigirá um código de análise e gerenciamento de posição muito mais complexo do que a função 2.1.4.
Mas tudo é possível.
Abraço
Olá Ais
Obrigado por sua rápida resposta. Eu posso seguir muito do que você afirma. Especialmente sobre a função iATR. Seu ditado de que o uso da expressão iBaseLag + iBasebar, por si só, é uma parte excepcional da fórmula. Eu tinha a impressão de que eles tinham que estar com os parâmetros de uma função definida ou eles não eram permitidos. Isto é para verificar o tamanho da história local, se realmente há barras suficientes para prosseguir. É isso que você está apontando? Muitos mais passos, mas passos necessários para atingir o objetivo. Passos que seriam negligenciados, ou tomados como garantidos.
Vou mastigar muito mais sobre o resto. Obrigado por seu tempo.
Saúde
Olá Huckleberry
MQL4 é um ambiente muito amigável, especialmente em comparação com, por exemplo, C ou montadoras.
Os requisitos para várias verificações e outros truques são significantemente reduzidos.
Mas implementações de verificações máximas possíveis no ambiente de desenvolvimento sempre reduzem o desempenho.
De qualquer forma, o programador é sempre responsável pelo mau comportamento do programa.
Portanto, para mim, a verificação redundante é melhor do que, por exemplo, a corrupção elementar de limites.
Saúde