Kapanış Sorunları, Lütfen yardım edin - sayfa 5

 

Merhaba Ayşe
Cevabınız sevindirici. Karmaşıklığı anlamama ve ardından karmaşıklığı azaltmama yardım edeceğini duymak, isteyebileceğimden daha fazlasıydı. Cömertliğinizin önünde kendimi alçaltıyorum. Teşekkür ederim.
Programlarınızdaki yorum yapısıyla ilgili bir sorum var. Gelişen düşünce treninden çıkmak istediğimden değil, formatın nasıl göründüğü sorusu bana tanıdık gelmiyor.

Misal:

// < 4 etki alanındaki 17 öğeyi yapılandırın > //< >
// < 1. Veri 2 etki alanındaki 8 öğe /> //< >
// < 2. 9 öğeyi 2 etki alanında kodlayın /> //< >
// </4 etki alanındaki 17 öğeyi yapı > //< >
// //< >
// < 1. Veri 8 = 5 ben 3 d - s > //< >
// < 1.1. Giriş 7 = 4 ben 3 d - s /> //< >
// < 1.2. Tampon 1 = 1 i - d - s /> //< >
// </1. Veri 8 = 5 ben 3 d - s > //< >
// //< >

Yorumlar çok net bir şekilde yapılandırılmıştır. Başlıklar ve alt yorumlarla, okuduklarımı tanımlamanın en iyi yolu olurdu. Sanki yorumlar bir kod makinesi tarafından geliştirilmiş ve biçimlendirilmiş veya yapılandırılmış gibi mi? Etkileyici. Yorumlanan her şeyi anladığımdan değil. Organizasyon yeteneğinizi canlandırıcı buluyorum.

Tekrar teşekkürler. Programı inceleyeceğim ve çok yakın gelecekte daha fazla sorum olacak.
Şerefe

 

Merhaba Huckleberry

Senden duyduğuma sevindim.


1. yapı

Yapı tarafımca geliştirilmiş ve biçimlendirilmiştir.

 //                                                                //<          >
// < 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       > //<          >
//                                                                //<          >
     

İlk amaç, global verileri ve kodu kesin olarak ayırmaktır.
Bilgisayar programı benim için gerçek dünyanın modelidir.
Küresel veriler bu dünyanın şeyleridir.
Kod, eylemler kümesidir.
Onları ayırarak, aralarındaki farkı anladığımın altını çiziyorum.
Öğelerin sayısını saymak, program içindeki her şeyi kontrol etmeme yardımcı oluyor.


2. biçimlendirme

Biçimlendirme basit bir HTML'dir.
Aşağıdaki etiket programın bir bölümünü açar:

 // <                                                            > //<          >
      


Aşağıdaki etiket programın bir bölümünü kapatır:

 // </                                                           > //<          >
      


Tek satırda programın bölümleri için aşağıdaki etiket kullanılır:

 // <                                                           /> //<          >
      

Sayfa sayımı için artık etiketin bitiş kısmı kullanılıyor.
Etiketlerin bu bölümünün gelecekte kullanımı genişletilebilir.

                                                                   //<          >
      

Sayfa yapısı, programda kolayca gezinmeye yardımcı olur.
<Page Up> ve <Page Down> kullanarak aynı yerlerde her zaman aynı türde etiketler görüyorum.


3. Öğeler

Veri öğesi, tek bir global değişkendir.
Ben de diziyi tek eleman olarak görüyorum.
Yerel değişkenler, kod öğelerinin yalnızca geçici varlıklarıdır.

Kodun öğesi tek bir işlevdir .
Ayrıca "yöntem" kelimesini de kullanabilirim.
Birleşik işlevler kümesi için "arayüz" kelimesini kullanıyorum.

Karmaşıklığı azaltmak için verileri ve kodları mantıksal alanlarda ayırıyorum.
Etki alanı sayısı program yapısına bağlıdır.
Veriler için olağan alanlar: "giriş", "ayarlar", "kontrol", "tampon" ..
Kod için olağan etki alanları: özel işlevler kümesi için "özel", diğer işlevler kümesi için "arayüz".
Büyük programlar olması durumunda, farklı "arayüzlere" sahip "nesneler" oluşturabilirim.

Veri öğelerinin ve kod öğelerinin bütünlüğünü kontrol etmek için sayım kullanılır.

 //                                                                //<          >
// < 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   > //<          >
//                                                                //<          >
     

Açılış ve kapanış etiketleri aynı toplamları içerir.
Genellikle açılış etiketindeki toplamı sayarım.
Ardından, kapanış etiketi yerine açılış etiketini kopyalayıp ekliyorum ve ardından kapanış eğik çizgisini "/" ekliyorum.

Verilerin bütünlüğünü kontrol etmek için aşağıdaki gösterim kullanılır.
"Tamsayı"nın veri öğelerinin sayısı "i" olarak belirtilir.
"Çift" in veri elemanlarının sayısı "d" olarak not edilir.
"Dize"nin veri öğelerinin sayısı "s" olarak belirtilir.
Sol sütun, "i" + "d" + "s" satırının toplamını içerir.

Kodun bütünlüğünü kontrol etmek için aşağıdaki gösterim kullanılır.
İşlev girdilerinin sayısı, yani işlev argümanlarının sayısı "i" olarak not edilir.
Açık kod satırlarının sayısı "l" olarak belirtilir.
Fonksiyon çıkışlarının sayısı "o" olarak belirtilir.
Herhangi bir değer döndüren tek işlev için her zaman "1" ve diğer tüm durumlarda "-".
Sol sütun, etki alanındaki işlevlerin sayısını içerir.


4. Etki alanları

Bunlar alan adlarının başlıklarıdır.

 ////////////////////////////////////////////////////////////////////<         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   > //<          >
//                                                                //<          >
     


Sayma kuralları ve gösterimleri, programın başlığı ile aynıdır.
Sadece alan başlıklarının açılış etiketlerini programın başlığına kopyalıyorum.

Alan adındaki her sayfanın açılış ve kapanış etiketleri vardır.
Örneğin:

 ////////////////////////////////////////////////////////////////////<        12>
// < 2.2.1. Code : Special : Init >                               //<          >
..
// </2.2.1. Code : Special : Init >                               //<          >
     

Yapının bölümlerinin sayılması ve gezinmesi için önde gelen sayılar kullanılır.
Ardından "Veri" veya "Kod" programının bir parçası için gösterimi takip eder.
Ardından etki alanı adını takip eder.
Ardından etki alanı öğesinin adını izler.


Umarım bu yardımcı olabilir.

Şimdilik hoşçakalın ve cevabınızı bekliyorum

 

Merhaba Ayşe
Örgütlenme anlayışınız ......nasıl söylenebilir ki ..... pratik ve mantıklı.
HTML'yi entegre etmek, gezinmeyi kolaylaştırır, ancak şu anda beni aşıyor.
Çok iyi.
Şu anda, bana gönderdiğiniz programı her seferinde bir ifade olmak üzere parçalara ayırıyorum. Konseptler
Değişkenler üzerinde var, anlaşılabilir. Tekrar teşekkürler.
Emin olduğum sorulara cevap vereceğim.
Hoşçakal

 

Merhaba Ais,,,<bu düzenlendi>
Program henüz özümsenmemiştir. Üzgünüm, çok zamanınızı alıyor. Kaçırdığım bir alan var,
çünkü uğraşmam gereken bir hata var.
Şimdilik gitmeliyim ama yarın döneceğim.
Şimdilik hoşça kal

 

Merhaba Huckleberry
Örneğin bazı özellikler eklendi ve kolayca değiştirilebilir veya kaldırılabilir .
Programın iyileştirilmesi sonsuz bir süreçtir.
Şimdilik hoşça kal
:)

 
Ais wrote >>

Merhaba Huckleberry
Örneğin bazı özellikler eklendi ve kolayca değiştirilebilir veya kaldırılabilir.
Programın iyileştirilmesi sonsuz bir süreçtir.
Şimdilik hoşça kal
:)


Merhaba Ayşe
Yaptığın her şey için teşekkür ederim.
Dün gece programınızı kopyalarken sonunda hatamı buldum.
Şu anda bazı değişkenlerin ne işe yaradığını ve nasıl çalışacaklarını anlamaya çalışıyorum.
iSignalClose, OrderClosePrice'ı oluşturmak için diğer programımın bir bölümünü eklediğim yerdir. İle
senin önerin:

dDelta = OrderOpenPrice () - OrderClosePrice

program daha fazla esnekliğe sahiptir.
Daha fazla soruyla geri dönün. Ve yorumlar.
Şerefe
 

Merhaba Ayşe
Sorular oluştu. Programınız ..... iTryOpen () şeklinde belirtiyor

 else if      ( iCommand       == OP_BUY )
   {          
string         sType           = "Buy"    ;   
int            iColor          =   Blue    ;               }
else          
   {          sType           = "Sell"   ;    
              iColor          =   Red     ;           

Merakımdan, olmalı mı

 else if      ( iCommand       == OP_BUY  )
   {          
string         sType           = "Buy"    ;   
int            iColor          =   Blue    ;               }
else if      ( iCommand       == OP_SELL )   // Was this ommitted     
   {          sType           = "Sell"   ;    
              iColor          =   Red     ;               }
İşte daha iyi anlamak için başka bir soru
 // < 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 ) ; } //<          >
//                                                  
iNewBar TRUE ise, kontrol iSignalOpen'a geçirilir. iNewBar DOĞRU ise (geçerli çubuğa eşit mi??), VEYA iFirstRun ==1, o zaman iFirstBar = 0. Bu, yalnızca iNewBar () tanımını ve/veya iFirstRun tanımını anlamadığım için kafa karıştırıcıdır. iFirstRun'un nerede başladığını ve başlatıldığını görebiliyorum, ancak bu ne anlama geliyor.
Bu kadar basit sorular için sana yük olduğum için üzgünüm. İşlev içinde ikisinin nasıl çalıştığını hesaplayamıyorum veya göremiyorum. Vaktiniz olduğunda, lütfen bunu temizler misiniz?
çabalarınız için tekrar teşekkürler. :)
Şerefe
 

Merhaba Huckleberry

Her iki soru da önemlidir!

Cevap 1.

Her iki koşul da doğrudur, ancak eğer:
1.1. Biz biliyoruz ki

 int       iCommand          = iSignalOpen ()                    ; //<          >
     

1.2. "iSignalOpen ()" öğesinin yalnızca 3 olası değer döndürebileceğini biliyoruz: "EMPTY", "OP_BUY" ve "OP_SELL";
1.3. ilk değer zaten kontrol edildi

 if      ( iCommand         == EMPTY  )                return    ; //<          >
     

1.4. ikinci değer de kontrol edilir

 if      ( iCommand         == OP_BUY )                            //<          >
     

o zaman hesaplamaları biraz hızlandırmak için son kontrolü "eğer" atlamak mümkündür.

 else if     ( iCommand       == OP_SELL )                    //<          >
     


Cevap 2.

2.1. 0 numaralı çubuğun açılış zamanı ile 0 numaralı çubuğun en son saklanan açılış zamanı karşılaştırılarak 0 numaralı çubuğun değiştirildiğini biliyoruz.
"iTime (0, 0, 0 )" mevcut tamamlanmamış çubuğun açılma zamanını döndürür.
Geçerli çubuğun dizini her zaman 0'dır, "iTime (0, 0, 0 )" içindeki üçüncü değerdir.
"int iTime_0" değişkenini "statik" olarak bildirmek, bu değişkenin değerinin işlev çağrıları arasında kaydedildiği anlamına gelir.
Açılış saati her değiştirildiğinde, biz:
2.1.1. "iTime_0 = iTime ( 0, 0, 0 ) ;" ata mevcut çubuğun açılış saatini saklamak için;
2.1.2. "TRUE" döndür, bu, mevcut çubuğun yeni bir çubuk olduğu anlamına gelir, son çubuk numarası 0, çubuk numarası 1 olur.

 ////////////////////////////////////////////////////////////////////<         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. "iSignalOpen ()" içindeki "dHigh" ve "dLow" ve "iSignalClose ()" içindeki "dATR" hesaplamaları için başlangıç çubuğumuz "iBaseBar=1"'dir.
1 numaralı çubuk aynı olmakla birlikte bu değerler aynıdır.
Bu değerleri yalnızca yeni çubuklarda hesaplamak için bir nedendir.
Bu programı hızlandırır.
"static int iFirstRun" değişkeni basit bir tetikleyicidir.
"1" başlangıç değeri, herhangi bir koşula bakılmaksızın, ilk program çalıştırmasında "dHigh", "dLow" ve "dATR" hesaplamasını zorlar.
Bu, programın güvenilirliğini artırır.

<sonra eklendi>
Aynen, ilk programda "iSignalOpen ()" içindeki "iNewBar ()" çalıştırıldığında "DOĞRU", "iSignalClose"da "BOŞ" döndürülür!
Bunun nedeni, "iNewBar ()" öğesinin ilk çalıştırılmasında, yani "iSignalOpen ()" öğesinin ilk çalıştırılmasının içinde, "iTime_0 = 0" değerinin ve "iNewBar ()" öğesinin ikinci çağrılmasında, yani birincinin içinde olmasıdır. "iSignalClose ()", "iTime_0 = iTime (0, 0, 0 )" çalıştırması!
Sonuç olarak, ilk çalıştırma kontrolü olmadan "dATR = 0" olabilir.
İlk çalıştırma böyle.
</daha sonra eklendi>

Bundan hemen sonra "iFirstRun = 0" atadık ve aşağıdaki koşul yalnızca yeni çubuklarda geçerli olacaktır:

 if    ( ( iNewBar () == TRUE )   ||   ( iFirstRun  == 1 ) )       //<          >
     

Ancak!
"iSignalOpen ()" ve "iSignalClose ()" kodlarının kalanları her tikte yürütülür!
Yalnızca değişmeyen değerlerin hesaplamaları atlanır.

 ////////////////////////////////////////////////////////////////////<         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 >                      //<          >
     


Umarım bu yardımcı olabilir.
Şerefe!
:)

PS Bazı açıklamalar sonradan eklendi.
Ve bu açıklamalara bakıldığında, "iNewBar()"ın düzeltilmesi gerektiği açıktır.
Bunun nedeni, bu işlevin tek bir olayı kontrol etmek için iki kez çağrılmasıdır.
Şimdi, aynı olay için ilk çağrıda "iNewBar ()" doğru değeri, ikincisinde ise yanlış değeri döndürür.
düzeltilecektir.



 

Merhaba Ayşe
Açıklama için teşekkür ederim. Daha fazla okuma ile takip edeceğim. Henüz kod üzerinde tam bir tanıtıcım yok.
Ama iNewBar'a kadar düzeltilmesi gereken bir şey olduğundan bahsetmiştiniz? Backtest'in ortaya çıkardığı sorun için iNewBar'ın hatalı olduğundan emin değilim. Olası iki sorun??
Geriye dönük bir testten sonra grafiği açtığımda gördüklerim bunlar. Sor, son yirmi çubuğun en yüksek seviyesinin üzerinde olduğunda bir Satın Al girişi olduğunu biliyoruz. Satış ise tam tersi. Yine de girişler tutarlı değil. Bu gördüğün alan mı?
Bir şey daha buldum. Sabit Durdurma, Atr*2 olarak hesaplanır. Bu doğru, ancak bunun nerede hesaplandığını göremiyorum. Ancak asıl sorun, TakeProfit'in aynı Atr*2 hesaplamasına sahip olmasıdır. Sabit Durmanın nerede hesaplandığını bilseydim, TakeProfit'i düzeltebilirdim. Bu durumda TakeProfit yalnızca Atr*1 olmalıdır.
Kendine iyi bak, yarın döneceğim.
Şerefe

 

Merhaba Huckleberry

TakeProfit koşulu tarafımca test amaçlı icat edilmiştir.
Şimdi değiştirildi.
"Atr*2" ve "Atr*1" yerine "dATR * dFactorTP" ve "dATR * dFactorSL" kullanıyorum.
"dFactorTP = 1.0" ve "dFactorSL = 2.0" başlangıç değerleri, 2. "Veri: Giriş" sayfasındadır.
Bu tür bir çözüm, bu değerlerin kolayca optimize edilmesini sağlar.

"iSignalOpen ()" ve "iSignalClose ()" işlevlerini değiştirdim.
Yeni çubuğun kontrolü artık bu işlevlerde uygulanmaktadır.
"iSignalOpen ()" içindeki "Satın Al" ve "Sat" koşulları muhtemelen doğru gibi görünüyor.

Programın tamamı bir sonraki sayfada ekli dosyadadır.

Şerefe