Problemas de fechamento, por favor, ajude - página 5
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á, Ais
Sua resposta é de bom grado. Ouvir você me ajudaria a entender a complexidade e depois ajudar a reduzir a complexidade, foi mais do que eu poderia pedir. Eu me humilho diante de sua generosidade. Obrigado.
Tenho dúvidas quanto à estrutura de comentários em seus programas. Não que eu queira sair do trem de pensamento que progrediu, mas uma questão de como o formato não me é familiar.
Exemplo:
// < Estrutura 17 elementos em 4 domínios > //< >
// < 1. dados 8 elementos em 2 domínios /> //< > >
// < 2. código 9 elementos em 2 domínios /> //< > >
// </estrutura 17 elementos em 4 domínios > //< >
// //< >
// < 1. dados 8 = 5 i 3 d - s > //< >
// < 1.1. Entrada 7 = 4 i 3 d - s /> //< > > > 1.1.
// < 1.2. Buffer 1 = 1 i - d - s /> //< > > > 1.2.
// </1. Dados 8 = 5 i 3 d - s > //< > >
// //< >
Os comentários são estruturados de forma percisiva. Com títulos e sub-comentários, seria a melhor maneira para eu descrever o que leio. Como se os comentários fossem desenvolvidos e formatados ou estruturados por uma máquina de código?? É impressionante. Não que eu entenda tudo o que é comentado. Sua habilidade na organização me parece refrescante.
Mais uma vez, obrigado. Estarei estudando o programa e terei mais perguntas em um futuro muito próximo.
Saúde
Olá Huckleberry
Fico feliz em saber de você.
1. A estrutura
A estrutura é desenvolvida e formatada por mim mesmo.
// //< > // < Structure 16 elements in 4 domains > //< > // < 1. Data 7 elements in 2 domains /> //< > // < 2. Code 9 elements in 2 domains /> //< > // </Structure 16 elements in 4 domains > //< > // //< >A primeira intenção é separar estritamente os dados globais e o código.
O programa de computador para mim é modelo do mundo real.
Os dados globais são as coisas deste mundo.
O código é o conjunto de ações.
Separando-os, estou sublinhando que compreendo a diferença entre eles.
Contar o número de elementos me ajuda a verificar e controlar tudo dentro do programa.
2. A formatação
A formatação é um simples HTML.
A seguinte tag abre a parte do programa:
// < > //< >A seguinte tag fecha a parte do programa:
// </ > //< >A seguinte tag é usada para partes do programa em uma única linha:
// < /> //< >A parte final da tag agora é usada para a contagem de páginas.
No futuro, o uso desta parte da tag poderá ser estendido.
//< >A estrutura da página ajuda a navegar facilmente através do programa.
Usando <Página acima> e <Página abaixo> vejo sempre os mesmos tipos de tags nos mesmos lugares.
3. Os elementos
O elemento de dados é uma única variável global.
Eu vejo array como o elemento único também.
As variáveis locais são apenas entidades temporárias de elementos de código.
O elemento de código é uma função única.
Também posso usar a palavra "método".
Eu uso a palavra "interface" para um conjunto unificado de funções.
Para reduzir a complexidade, eu desenvolvo dados e códigos em domínios lógicos.
O número de domínios depende da estrutura do programa.
Domínios usuais para dados: "input", "settings", "control", "buffer" ...
Domínios usuais para código: "especial" para conjunto de funções especiais, "interface" para conjunto de outras funções.
No caso de programas grandes, posso criar "objetos" com diferentes "interfaces".
Para controlar a integridade dos elementos de dados e elementos de código é usada a contagem.
// //< > // < 1. Data 7 = 4 i 3 d - s > //< > // < 1.1. Input 7 = 4 i 3 d - s /> //< > // < 1.2. Buffer - = - i - d - s /> //< > // </1. Data 7 = 4 i 3 d - s > //< > // //< > // < 2. Code 9 / - i 82 l 4 o > //< > // < 2.1. Interface 6 / - i 71 l 4 o /> //< > // < 2.2. Special 3 / - i 11 l - o /> //< > // </2. Code 9 / - i 82 l 4 o > //< > // //< >As etiquetas de abertura e fechamento contêm as mesmas somas.
Normalmente eu conto a soma na etiqueta de abertura.
Então eu apenas copio e inseri a tag de abertura ao invés da tag de fechamento e depois adiciono a barra de fechamento "/".
Para controlar a integridade dos dados, a seguinte notação é usada.
O número de elementos de dados do "número inteiro" é anotado como "i".
O número de elementos de dados do "duplo" é anotado como "d".
O número de elementos de dados de "string" é anotado como "s".
A coluna da esquerda contém a soma da linha "i" + "d" + "s".
Para controlar a integridade do código, a seguinte notação é usada.
O número de entradas de funções, ou seja, o número de argumentos de funções, é anotado como "i".
O número de linhas abertas de código é anotado como "l".
O número de saídas de função é anotado como "o".
Sempre "1" para uma única função que retorna qualquer valor e "-" em todos os outros casos.
A coluna da esquerda contém o número de funções no domínio.
4. Os domínios
Estes são os cabeçalhos dos domínios.
////////////////////////////////////////////////////////////////////< 2> // < 1.1. Data : Input > //< > // //< > // < 1.1. Input 7 = 4 i 3 d - s > //< > // < 1. Strategy 4 = 2 i 2 d - s /> //< > // < 2. Trading 3 = 2 i 1 d - s /> //< > // </1.1. Input 7 = 4 i 3 d - s > //< > // //< >////////////////////////////////////////////////////////////////////< 3> // < 1.2. Data : Buffer > //< > // //< > // < 1.2. Buffer - = - i - d - s > //< > // </1.2. Buffer - = - i - d - s > //< > // //< >////////////////////////////////////////////////////////////////////< 4> // < 2.1. Code : Interface > //< > // //< > // < 2.1. Interface 6 / - i 71 l 4 o > //< > // < 1. iNewBar - i 4 l 1 o /> //< > // < 2. iSignalOpen - i 15 l 1 o /> //< > // < 3. iSignalClose - i 15 l 1 o /> //< > // < 4. iGetTicket - i 7 l 1 o /> //< > // < 5. iTryOpen - i 15 l - o /> //< > // < 6. iTryClose - i 15 l - o /> //< > // </2.1. Interface 6 / - i 71 l 4 o > //< > // //< >////////////////////////////////////////////////////////////////////< 11> // < 2.2. Code : Special > //< > // //< > // < 2.2. Special 3 / - i 11 l - o > //< > // < 1. init - i 1 l - o /> //< > // < 2. deinit - i 1 l - o /> //< > // < 3. start - i 9 l - o /> //< > // </2.2. Special 3 / - i 11 l - o > //< > // //< >As regras e notações para a contagem são as mesmas que para o cabeçalho do programa.
Eu apenas copio as tags de abertura dos cabeçalhos dos domínios para o cabeçalho do programa.
Cada página no domínio tem tags de abertura e de fechamento.
Por exemplo, as tags de abertura e fechamento:
////////////////////////////////////////////////////////////////////< 12> // < 2.2.1. Code : Special : Init > //< > .. // </2.2.1. Code : Special : Init > //< >Os cabeçalhos são usados para a contagem e navegação das partes da estrutura.
Em seguida, segue a notação para a parte do programa "Dados" ou "Código".
Em seguida, segue o nome do domínio.
Em seguida, segue o nome do elemento de domínio.
Espero que isto possa ajudar.
Adeus por enquanto e aguardando sua resposta
Oi Ais
Seu senso de organização é ......como se pode dizer ..... praticar e ser sensato.
Intigrar o HTML facilita a navegação, apesar de estar além de mim neste momento.
Muito bom.
Neste momento, estou desleixando o programa que você me enviou, uma declaração de cada vez. Os conceitos
que você tem sobre as variáveis, são compreensíveis. Mais uma vez, obrigado.
Responderei com perguntas, tenho certeza.
Tchau
Olá Ais,,<isso já foi editado>
O programa ainda não foi absorvido. Lamento que esteja tomando tanto de seu tempo. Há uma área que eu devo ter perdido,
porque eu tenho um erro a enfrentar.
Devo ir por enquanto, mas voltarei amanhã.
Adeus por enquanto
Olá Huckleberry
Algumas características foram adicionadas, por exemplo, e podem ser facilmente alteradas ou removidas.
A melhoria do programa é um processo eterno.
Adeus por enquanto
:)
Olá Huckleberry
Algumas características foram adicionadas, por exemplo, e podem ser facilmente alteradas ou removidas.
A melhoria do programa é um processo eterno.
Tchau por enquanto
:)
Olá, AisObrigado por tudo o que você fez.
Na noite passada, finalmente encontrei meu erro enquanto copiava seu programa.
Neste momento, estou tentando entender para que servem algumas das variáveis e como elas funcionariam.
O iSignalClose é onde estou inserindo parte do meu outro programa para estabelecer o OrderClosePrice. Com
sua sugestão:
dDelta = OrderOpenPrice () - OrderClosePrice
o programa tem mais flexibilidade.
Volte com mais perguntas. E comentários.
Saúde
Olá Ais
As perguntas ocorreram. Seu programa diz em ..... iTryOpen ()
Por minha curiosidade, se houvesse
Aqui está outra questão para melhor compreensão Se o iNewBar for VERDADEIRO, o controle é passado para o iSignalOpen. Se iNewBar é VERDADEIRO (igual à barra atual??), OU iFirstRun ==1, então iFirstBar = 0. Isto é confuso somente porque eu não entendo a definição iNewBar () e/ou a definição iFirstRun. Posso ver onde o iFirstRun é decodificado e inicializado, mas o que isso significa.Desculpe-me por sobrecarregá-lo com perguntas tão simples. Não consigo calcular ou ver como os dois funcionam dentro da função. Quando você tiver tempo, poderia esclarecer isto, por favor.
Mais uma vez, obrigado por seus esforços : )
Saúde
Olá Huckleberry
Ambas as perguntas são importantes!
Resposta 1.
Ambas as condições são verdadeiras, mas se:
1.1. soubermos que
int iCommand = iSignalOpen () ; //< >1.2. sabemos que "iSignalOpen ()" pode retornar apenas 3 valores possíveis: "EMPTY", "OP_BUY" e "OP_SELL";
1.3. O primeiro valor já é verificado
if ( iCommand == EMPTY ) return ; //< >1.4. O segundo valor também é verificado
if ( iCommand == OP_BUY ) //< >então é possível omitir a última verificação "se" para acelerar ligeiramente os cálculos.
else if ( iCommand == OP_SELL ) //< >Resposta 2.
2.1. Reconhecemos que a barra número 0 é alterada comparando-se o tempo de abertura da barra número 0 com o último tempo de abertura armazenado da barra número 0.
"iTime ( 0, 0, 0 )" retorna o tempo de abertura da barra incompleta atual.
Índice da barra atual é sempre 0, é o terceiro valor em "iTime ( 0, 0, 0 )".
Declarando a variável "int iTime_0" como "estática" significa que o valor desta variável é salvo entre as invocações da função.
Cada vez que o tempo de abertura é alterado, nós:
2.1.1. atribuímos "iTime_0 = iTime ( 0, 0, 0 ) ;" para armazenar o tempo de abertura da barra atual;
2.1.2. retornamos "TRUE" que significa que a barra atual é uma nova barra, a última barra número 0 tornou-se a barra número 1.
////////////////////////////////////////////////////////////////////< 5> // < 2.1.1. Code : Interface : iNewBar > //< > int iNewBar () // - i 4 l 1 o //< > { //< > static int iTime_0 = 0 ; //< > // //< > if ( iTime_0 < iTime ( 0 , 0 , 0 ) ) //< > { iTime_0 = iTime ( 0 , 0 , 0 ) ; return ( TRUE ) ; } //< > else { return ( EMPTY ) ; } //< > } //< > // </2.1.1. Code : Interface : iNewBar > //< >2.2. Nossa barra inicial para cálculos de "dHigh" e "dLow" em "iSignalOpen ()", e "dATR" em "iSignalClose ()", é "iBaseBar=1".
Embora a barra número 1 seja a mesma, estes valores são os mesmos.
É uma razão para computar estes valores somente em barras novas.
Isto acelera o programa.
A variável "static int iFirstRun" é um gatilho simples.
O valor inicial "1" força o cálculo de "dHigh", "dLow" e "dATR" na primeira execução do programa, independentemente de qualquer condição.
Isto melhora a confiabilidade do programa.
<adicionado mais tarde>
Exatamente, no primeiro programa rodar "iNewBar ()" em "iSignalOpen ()" retorna "TRUE", e em "iSignalClose" retorna "EMPTY"!
Isto porque na primeira invocação de "iNewBar ()", que está dentro da primeira execução de "iSignalOpen ()", o valor de "iTime_0 = 0".e na segunda invocação do "iNewBar ()", ou seja, dentro da primeira execução do "iSignalClose ()", "iTime_0 = iTime ( 0, 0, 0 )"!
Como resultado, sem a primeira execução do controle pode ser "dATR = 0".
Esta é a primeira execução.
</adicionado mais tarde>
Imediatamente depois disso, atribuímos "iFirstRun = 0" e a seguinte condição será válida somente em barras novas:
if ( ( iNewBar () == TRUE ) || ( iFirstRun == 1 ) ) //< >Mas!
Restos do código de "iSignalOpen ()" e "iSignalClose ()" executados em cada tick!
Somente os cálculos de valores inalterados são pulados.
////////////////////////////////////////////////////////////////////< 6> // < 2.1.2. Code : Interface : iSignalOpen > //< > int iSignalOpen () // - i 15 l 1 o //< > { //< > static int iFirstRun = 1 ; //< > if ( ( iNewBar () == TRUE ) || ( iFirstRun == 1 ) ) //< > { iFirstRun = 0 ; //< > int iIndexH = iHighest ( 0 , 0 , MODE_HIGH , //< > iBaseLag , iBaseBar ) ; //< > int iIndexL = iLowest ( 0 , 0 , MODE_LOW , //< > iBaseLag , iBaseBar ) ; //< > static double dHigh ; dHigh = High [ iIndexH ] ; //< > static double dLow ; dLow = Low [ iIndexL ] ; //< > } // if //< > // //< > double dAsk = MarketInfo ( Symbol () , MODE_ASK ) ; //< > if ( dAsk > dHigh ) return ( OP_BUY ) ; //< > // //< > double dBid = MarketInfo ( Symbol () , MODE_BID ) ; //< > if ( dBid < dLow ) return ( OP_SELL ) ; //< > // //< > return ( EMPTY ) ; //< > } //< > // </2.1.2. Code : Interface : iSignalOpen > //< >Espero que isto possa ajudar.
Saúde!
:)
P.S. Algumas observações acrescentadas posteriormente.
E, olhando para estas observações, é óbvio que "iNewBar ()" tem que ser corrigido.
Isto porque esta função foi invocada duas vezes para verificar um único evento.
Agora, para o mesmo evento na primeira invocação "iNewBar ()" retorna o valor correto, e na segunda retorna o valor incorreto.
Será corrigido.
Oi Ais
Obrigado pelo esclarecimento. Vou acompanhar com mais leitura. Ainda não tenho um controle completo sobre o código.
Mas você mencionou que havia algo que tinha que ser corrigido até o iNewBar?? Não tenho certeza se o iNewBar é culpado pelo problema que o backtest revelou. Possíveis dois problemas??
Eis o que eu vi quando abri o gráfico após um backtest. Sabemos que há uma entrada Buy quando o Ask está acima da mais alta das últimas vinte barras. A Venda é exatamente o oposto. No entanto, as entradas não são consistentes. É esta a área que você viu?
Encontrei mais uma coisa. A parada dura é calculada Atr*2. Isto é correc, mas não vejo onde isto é calculado. Mas o verdadeiro problema é que o TakeProfit tem o mesmo cálculo de Atr*2. Se eu soubesse onde o Stop Duro é calculado, eu poderia corrigir o TakeProfit. Neste caso, TakeProfit deveria ser apenas Atr*1.
Tome cuidado e estarei de volta amanhã.
Saúde
Olá Huckleberry
TakeProfit condição foi inventada por mim para fins de teste.
Agora foi alterada.
Em vez de "Atr*2" e "Atr*1" eu uso "dATR * dFactorTP" e "dATR * dFactorSL".
Os valores iniciais "dFactorTP = 1,0" e "dFactorSL = 2,0" estão na página 2 "Dados : Input".
Tal solução permite otimizar facilmente estes valores.
Alterei as funções "iSignalOpen ()" e "iSignalClose ()".
A verificação de nova barra agora está implementada nestas funções.
As condições para "Comprar" e "Vender" em "iSignalOpen ()" parecem provavelmente corretas.
O programa completo está em arquivo anexo na próxima página.
Saúde