Sıfırdan Kodlayarak Algoritmik Trade (Ticaret) Eğitimi

Değişkenler

C# programlama dilinde, değişkenler verileri geçici olarak saklamak ve işlemek için kullanılan temel yapı taşlarıdır. Değişkenler isimlendirilmiş bellek alanlarıdır ve farklı veri tiplerinde değerler alabilirler. Bir değişkenin içeriği program akışı içinde değiştirilebilir, bu nedenle adı "değişken"dir.

Değişkenleri tanımlamak için öncelikle veri türünü ve değişkenin ismini belirtmemiz gerekmektedir. C# dilinde yaygın kullanılan veri tipleri şunlardır:

• int: Tam sayı değerlerini saklamak için kullanılır. Örneğin: int age = 25; (Yaş değeri 25 olarak atanır)

• double: Ondalıklı sayıları saklamak için kullanılır. Örneğin: double price = 19.99; (Fiyat değeri 19.99 olarak atanır)

• string: Metin veya karakter dizilerini saklamak için kullanılır. Örneğin: string name = "yigit";

• bool: Mantıksal değerleri (true veya false) saklamak için kullanılır. Örneğin: bool isActive = true; (isActive değeri true olarak atanır)

Bir de bu tanımlamalara ek olarak C# dilinde "var" değişkeni, tür belirtilmeden kullanılan bir değişken türüdür. Yani, değişkenin türünü açıkça belirtmek yerine, C# diline bırakarak değişkenin türünü otomatik olarak tespit etmesini sağlar.

Örnek olarak, "var" değişkenini kullanarak değişkenler tanımlayalım:

var number = 10; // "number" değişkeni tam sayı türünde olacak şekilde otomatik olarak belirlenir.

var surname = "tunc"; // Burada "surname" isimli değişken string olarak tutulur.

var isActive = true; // Burada ise "isActive" true veya false değerini tutan bool mantıksal değerine bürünmüştür.

Ancak "var" değişkeni, derleme anında türünü belirlediği için, atama anında tür belirli olmalıdır. Yani, başlangıç değeri olmayan veya birden fazla tür içeren bir ifade kullanılamaz.

"Var" değişkeni genellikle yerel değişkenler için kullanılırken, bazı durumlarda nesne türleri gibi daha karmaşık türlerde de kullanılabilir. Ancak, genellikle değişkenin türünü açıkça belirtmek, kodun anlaşılırlığı ve bakımı açısından tercih edilen bir yaklaşımdır. Bu yaklaşım genellikle tercih edildiği gibi kullanılmaktadır.

C# Programlama Dilinde Aritmetik Operatörler

Aritmetik operatörler, C# programlama dilinde matematiksel işlemler gerçekleştirmek için kullanılan temel yapı taşlarıdır. Bu operatörler, sayılar üzerinde çeşitli işlemler yapmanıza olanak tanır. İşte C# dilinde kullanılan yaygın aritmetik operatörler:

1. Toplama (+): İki sayıyı toplamak için kullanılır.

Örnek:

int sonuc = 5 + 3; // sonuc değişkenine 5 + 3 işlemi sonucu olan 8 atanır

2. Çıkarma (-): Bir sayıdan diğerini çıkarmak için kullanılır.

Örnek:

int fark = 10 - 4; // fark değişkenine 10 - 4 işlemi sonucu olan 6 atanır

3. Çarpma (*): İki sayıyı çarpmak için kullanılır.

Örnek:

int carpim = 6 * 7; // carpim değişkenine 6 * 7 işlemi sonucu olan 42 atanır

4. Bölme (/): Bir sayıyı diğerine bölmek için kullanılır. Eğer bölen ve bölünensayılar tam sayı ise sonuç da tam sayı olur, ondalıklı ise ondalıklı sonuç üretilir.

Örnek:

double bolum = 15.0 / 2; // bolum değişkenine 15.0 / 2 işlemi sonucu olan 7.5 atanır

5. Mod Alma (%): Bir sayının diğerine bölümünden kalanı bulmak için kullanılır.

Örnek:

int kalan = 17 % 5; // kalan değişkenine 17 % 5 işlemi sonucu olan 2 atanır

6. Arttırma (++) ve Azaltma (--): Değişkenin değerini sırasıyla 1 artırmak veya azaltmak için kullanılır.

Örnek:

int sayi = 5;

sayi++; // sayi artık 6

sayi--; // sayi tekrar 5

Bu aritmetik operatörler, C# dilinde matematiksel işlemler yaparken sıkça kullanılan temel araçlardır. Bu operatörlerin kullanımıyla sayılar üzerinde çeşitli hesaplamalar gerçekleştirebilirsiniz.

C# Programlama Dilinde Koşulların Kullanımı

Koşullar, C# programlama dilinde belirli şartlar sağlandığında kod bloklarının çalıştırılmasını sağlayan yapıları ifade eder. "if", "else if" ve "else" anahtar kelimeleri ile belirli koşullara göre farklı kod bloklarının yürütülmesini yönlendirebiliriz.

Genel bir yapı olarak, koşullar şu şekilde ifade edilir:

if (koşul)

{

    // Eğer koşul doğruysa buradaki kod bloğu çalıştırılır.
}

else if (diğer_koşul)

{

    // Eğer "if" koşulu yanlış ve "else if" koşulu doğruysa buradaki kod bloğu çalıştırılır.

}

else

{

    // Yukarıdaki tüm koşullar yanlışsa buradaki kod bloğu çalıştırılır.

}

Koşullar, belirli şartları kontrol ederek, farklı senaryolara göre program davranışını ayarlama olanağı sunar. Örneğin, bir kullanıcı giriş yaptığında "Hoş geldiniz!" mesajını görüntülemek veya başarısız bir giriş durumunda "Hatalı giriş!" mesajını görüntülemek gibi senaryolarda koşullar kullanışlıdır.

Ayrıca, C# dilinde mantıksal operatörler (&&, ||, !) ve karşılaştırma operatörleri (==, !=, <, >, <=, >=) kullanarak daha karmaşık koşullar oluşturulabilir. Bu sayede birden fazla koşulu aynı anda kontrol etmek veya birbirine bağlı koşulları belirlemek mümkün olur. Bu konuyu bir sonraki derste öğrenerek koşullarımızı daha da geliştireceğiz.

C# dilinde koşullar, program akışını kontrol etmede kritik bir rol oynar. Bu yapı sayesinde kullanıcılar için gerçek dünya senaryolarına uygun tepkiler vermek ve daha etkili, özelleştirilmiş deneyimler sunmak mümkün olur. Koşulları doğru bir şekilde kullanarak kodlarımızı daha esnek ve kullanışlı hale getireceğiz.

C# Dilinde Karşılaştırma Operatörleri ve Kullanımları

C# programlama dilinde, karşılaştırma operatörleri değişkenlerin veya değerlerin birbirine göre ilişkisini değerlendirir ve sonuçlarına göre koşullar oluşturmak için kullanılır. Bu operatörler sıklıkla koşul ifadeleri ve döngülerde kullanılır.

"==" (Eşit) Karşılaştırma Operatörü: İki değeri birbirine eşit olup olmadığını kontrol eder. Eğer iki değer birbirine eşitse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (x == y)

{

    Console.WriteLine("x ve y birbirine eşittir.");

}

"!=" (Eşit Değil) Karşılaştırma Operatörü: İki değeri birbirine eşit olmadığını kontrol eder. Eğer iki değer birbirine eşit değilse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (x != y)

{

    Console.WriteLine("x ve y birbirine eşit değildir.");

}

"<" (Küçük) Karşılaştırma Operatörü: Bir değerin başka bir değerden küçük olup olmadığını kontrol eder. Eğer bir değer diğer değerden küçükse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (x < y)

{

    Console.WriteLine("x, y'den küçüktür.");

}

">" (Büyük) Karşılaştırma Operatörü: Bir değerin başka bir değerden büyük olup olmadığını kontrol eder. Eğer bir değer diğer değerden büyükse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (y > x)

{

    Console.WriteLine("y, x'den büyüktür.");

}

"<=" (Küçük veya Eşit) Karşılaştırma Operatörü: Bir değerin başka bir değerden küçük veya ona eşit olup olmadığını kontrol eder. Eğer bir değer diğer değerden küçük veya ona eşitse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (x <= y)

{

    Console.WriteLine("x, y'den küçük veya y'e eşittir.");

}

">=" (Büyük veya Eşit) Karşılaştırma Operatörü: Bir değerin başka bir değerden büyük veya ona eşit olup olmadığını kontrol eder. Eğer bir değer diğer değerden büyük veya ona eşitse ifade doğru döner, aksi takdirde yanlış döner.

Örnek:

int x = 5;

int y = 10;

if (y >= x)

{

    Console.WriteLine("y, x'den büyük veya x'e eşittir.");

}

Karşılaştırma operatörleri, programların farklı durumlarında farklı davranışlar sergilemesini sağlar. Bu operatörler sayesinde koşulların karşılaştırılması ve uygun şartlara göre yönlendirilmesiyle programlar daha esnek ve dinamik hale gelir. C# dilinde karşılaştırma operatörleri, koşulların ve program akışının kontrolünde kritik bir rol oynar.

C# Dilinde Mantıksal Operatörler ve Kullanımları

C# programlama dilinde, mantıksal operatörler birden fazla koşulu birleştirerek karmaşık koşullar oluşturmak için kullanılırlar. Genellikle koşulların doğru veya yanlış durumlarını değerlendirmek amacıyla kullanılırlar ve "&&" (ve), "||" (veya) ve "!" (değil) sembolleri ile temsil edilirler.

"&&" (Ve) Mantıksal Operatörü: Bu operatör, iki veya daha fazla koşulun tümünün doğru olması durumunda ifadeyi doğru döndürür. Eğer koşullardan en az biri yanlışsa ifade yanlış döner.

Örnek:

int age = 25;

bool isStudent = true;

if (age > 18 && isStudent)

{

    Console.WriteLine("Ehliyet alabilirsiniz ve öğrenci indiriminden yararlanabilirsiniz.");

}

"||" (Veya) Mantıksal Operatörü: Bu operatör, iki veya daha fazla koşulun en az birinin doğru olması durumunda ifadeyi doğru döndürür. Eğer koşullardan hiçbiri doğru değilse ifade yanlış döner.

Örnek:

bool isWeekend = false;

bool isHoliday = true;

if (isWeekend || isHoliday)

{

    Console.WriteLine("Bugün tatil günü!");

}

"!" (Değil) Mantıksal Operatörü: Bu operatör, belirtilen koşulun tersini alır. Eğer koşul doğruysa, "!" operatörü ile bu koşul yanlış olarak değerlendirilir; tam tersi durumda doğru olarak değerlendirilir.

Örnek:

bool isRaining = true;

if (!isRaining)

{

    Console.WriteLine("Bugün yağmur yok!");

}

Mantıksal operatörler, karmaşık koşulların oluşturulmasında ve birden fazla koşulun aynı anda kontrol edilmesinde önemlidir. Bu operatörler sayesinde programlar daha esnek ve özelleştirilmiş kararlar alabilir. Mantıksal ifadelerin kullanımı ve koşulların birleştirilmesi, programların işleyişini kontrol etme ve daha karmaşık senaryoları ele alabilme yeteneklerini artırır.

C# Dilinde İç İçe Koşulların Kullanımı

C# programlama dilinde, iç içe koşullar bir koşulun doğru olması durumunda başka bir koşulun kontrol edilmesi ve farklı senaryoların oluşturulması için kullanılır. İç içe koşullar, programların daha karmaşık senaryolara daha iyi cevap vermesini sağlar. Bu yapılar, mantıksal ve karşılaştırma operatörleriyle birleştirilerek belirli şartların bir araya getirilmesini ve daha kapsamlı kontrollerin yapılmasını sağlar.

Örnek olarak, bir alışveriş uygulaması düşünelim ve iç içe koşullar kullanarak farklı indirim tiplerini değerlendirelim:

int purchasedItems = 5;

double totalAmount = 100.0;

if (totalAmount >= 100.0)

{

    if (purchasedItems >= 5)

    {

        Console.WriteLine("Tebrikler, 5 veya daha fazla ürün alarak %10 indirim kazandınız!");

        totalAmount -= totalAmount * 0.1;

    }

    else

    {

        Console.WriteLine("Tebrikler, toplam tutar 100 TL veya daha fazla olduğu için %5 indirim kazandınız!");

        totalAmount -= totalAmount * 0.05;

    }

}

else

{

    Console.WriteLine("Üzgünüz, toplam tutar 100 TL altında olduğu için indirim kazanamadınız.");

}

Console.WriteLine("Ödemeniz gereken tutar: " + totalAmount + " TL");

Bu örnekte, alışverişte toplam tutar ve alınan ürün miktarına göre indirim uygulaması yapılmıştır. İlk iç içe koşulda, toplam tutarın 100 TL veya daha fazla olup olmadığı kontrol edilir. Eğer 100 TL veya daha fazlaysa ikinci iç içe koşula girilir ve alınan ürün miktarına bakılır. Eğer 5 veya daha fazla ürün alınmışsa %10 indirim uygulanır, aksi takdirde %5 indirim uygulanır. Eğer toplam tutar 100 TL altındaysa indirim yapılmaz.

Bu tür iç içe koşullar, programların karmaşık senaryolara uygun şekilde cevap vermesini sağlar. Mantıksal ve karşılaştırma operatörleri ile birleştirilen iç içe koşullar, daha kapsamlı karar yapıları oluşturmak için önemli bir araçtır. Programlarınızda farklı senaryolara göre aksiyonlar almak ve daha esnek bir yapı oluşturmak için iç içe koşulları ve mantıksal/karşılaştırma operatörlerini kullanabilirsiniz.

Başka bir koşul örneği ile devam edelim:

int age = 25;

bool isStudent = true;

if ((age >= 18 && age <= 30) || isStudent == true)

{

    Console.WriteLine("Ehliyet alabilirsiniz veya öğrenci olarak indirimden yararlanabilirsiniz.");

}

else

{

    Console.WriteLine("Ehliyet için yaş aralığında değilsiniz ve öğrenci indiriminden yararlanamazsınız.");

}

Bu şekilde, tek bir if satırında iki farklı koşulun ve mantıksal/karşılaştırma operatörlerinin bir arada kullanılarak programın davranışını kontrol etmek mümkündür. İç içe geçmiş koşullar ve mantıksal/karşılaştırma operatörleri, programlama sürecinde daha esnek ve karmaşık karar yapıları oluşturmak için kullanılan önemli araçlardır. Bu yapıları doğru ve etkili bir şekilde kullanarak programlarınızı daha güçlü hale getirebilirsiniz.

Döngülerin Kullanımı ve "for" Döngüsü

Döngüler, programlamada belirli bir işlemi tekrarlamak için kullanılan yapıları ifade eder. Bu sayede, aynı işlemi birden fazla kez yapmak veya bir liste veya dizideki elemanları sırayla işlemek gibi durumlar için döngüler oldukça faydalıdır. C# dilinde "for" döngüsü, belirli bir başlangıç değeriyle başlar, belirli bir şart sağlandığı sürece devam eder ve belirli bir adımla işlemi yineleyerek sonlanır.

"for" döngüsü, aşağıdaki şekilde kullanılır:

for (başlangıç_değer; şart; adım)

{

    // Döngü içinde yapılacak işlemler

}

"başlangıç_değer": Döngü değişkeninin başlangıç değerini belirtir. Döngü bu değerle başlar. "şart": Döngü değişkeni bu şartı sağladığı sürece döngü devam eder. Şart sağlanmadığında döngü sona erer. "adım": Döngü değişkeninin değerini güncellemek için kullanılan adımdır. Her döngü adımında bu adım kadar arttırılır veya azaltılır.

Örneğin, 0'dan 9'a kadar olan sayıları ekrana yazdıran bir "for" döngüsü şu şekilde olabilir:

for (int i = 0; i < 10; i++)

{

    Console.WriteLine("Sayı: " + i);

}

Bu örnekte, "i" değişkeni 0'dan başlayarak 9'a kadar tekrar eden bir döngü oluşturur. Her döngü adımında "i" değeri ekrana yazdırılır ve "i" değişkeni 1 arttırılarak döngü devam eder. Sonuç olarak, 0, 1, 2, 3, 4, 5, 6, 7, 8 ve 9 sayıları ekrana yazdırılır.

Böylece, "for" döngüsü belirli bir adım sayısıyla veya belli bir şartı sağlayana kadar işlemleri tekrar etmek için kullanılır. Bu sayede, programlarınızda tekrar eden işlemleri daha kolay ve verimli bir şekilde gerçekleştirebilirsiniz. "for" döngüsü, C# dilinde sıklıkla kullanılan ve programlamada önemli bir yapıdır.

Dizilerin Kullanımı ve Örnekler

Diziler, C# programlamada aynı veri tipine sahip birden fazla değeri tek bir değişken altında saklamak ve yönetmek için kullanılan yapıları ifade eder. Diziler, genellikle aynı türden verileri gruplamak ve bu verilere erişmek için kullanılır. Dizi elemanları, sıfır tabanlı indeksleme ile erişilir, yani ilk eleman 0, ikinci eleman 1, üçüncü eleman 2 şeklinde indekslenir.

C# dilinde diziler aşağıdaki şekilde tanımlanır:

veri_tipi[] dizi_adı = new veri_tipi[eleman_sayısı];

Örneğin, bir tamsayı dizisi tanımlamak için:

int[] numbers = new int[5];

Dizilere eleman atamak ve erişmek için indeksler kullanılır:

numbers[0] = 10;

numbers[1] = 20;

Dizi elemanlarına erişirken indeksler sıfırdan başlar, yani numbers[0] ilk elemana, numbers[1] ikinci elemana erişir.

Dizileri oluşturduktan sonra döngülerle elemanlara kolayca erişebilirsiniz. Örneğin, bir tamsayı dizisinin elemanlarını ekrana yazdırmak için:

for (int i = 0; i < numbers.Length; i++)

{

    Console.WriteLine("Eleman " + i + ": " + numbers[i]);

}

Ayrıca, dizileri dizi başlatıcılarıyla da oluşturabilirsiniz:

int[] primes = { 2, 3, 5, 7, 11 };

Diziler aynı veri tipinden oluştuğu için, aynı tipteki elemanları içinde barındırabilirler. Örneğin, bir dizide metin dizisi (string) elemanları saklayabilirsiniz:

string[] names = { "Ahmet", "Mehmet", "Ayşe", "Fatma" };

Diziler, verileri gruplamak, depolamak ve işlemek için önemli bir araçtır. Özellikle birden fazla benzer veriyle çalışırken, diziler programınızın daha düzenli ve verimli olmasını sağlar. Dizileri kullanarak verileri toplayabilir, işleyebilir ve sonuçlar elde edebilirsiniz.

Dizilere ilişkin bu temel bilgileri öğrendikten sonra, C# dilinde dizileri kullanarak daha karmaşık yapılar ve algoritmalar oluşturabilirsiniz. Bu sayede programlarınızı daha özelleştirilmiş ve güçlü bir şekilde tasarlayabilirsiniz.

Temel kavramları öğrendik ve artık C# dilinde kodlama konusunda bir temel bilgiye sahibiz. Eğer kodlama sürecinde ufak soru işaretleri varsa, daha sonrasında yapacağımız pratik ve örneklerle bu soru işaretlerini çözeceğimizi düşünüyorum. Şimdi bir sonraki adıma geçiyoruz ve öğrendiklerimizi Idealgo programı üzerinde kullanarak kendi algoritmik ticaret robotumuzu yazmaya başlayacağız. Bu program sayesinde, finansal piyasalarda otomatik alım-satım stratejileri oluşturacak ve robotumuzu gerçek piyasa verileriyle test ederek performansını gözlemleyeceğiz.

Öncelikle robotumuzun çalışabilmesi için bazı değişkenler tanımlamamız gerekiyor, bu değişkenler sabit olacak, 1 kez tanımlanacak ve en başta her zaman bulunacak.

// SİSTEM TANIMLAMALARI

var C = Sistem.GrafikFiyatSec("Kapanis");

var L = Sistem.GrafikFiyatSec("Dusuk");

var H = Sistem.GrafikFiyatSec("Yuksek");

var O = Sistem.GrafikFiyatSec("Acilis");

var sonYon ="F";

var sinyal = "F";

double alimFiyati= 0 ;

double satimFiyati = 0 ;

for (var i = 5; i < Sistem.BarSayisi ; i++)

{

}

Şimdi genel yapıyı anladığımıza göre ilk alım ve satım komutlarımızı vereceğimiz şartları yazacağımız yapıyı kuralım.

//--------------- AL VE SAT KOŞULU ---------------------

if() {

Sinyal ="A"; // ALIM KOŞULU

}

//********************************

if( ){

Sinyal = "S"; // SATIM KOŞULU

}

Aynı bu mantık ile düşünürsek ileride yazacağımız stop ve kar al noktalarında ise flat sinyalini kullanacağız.

//********************************

if( ){

Sinyal = "F"; // Flat KOŞULU

}

Birkaç ders sonra ise buradaki if koşullarının içerisine hangi şartlarda alım ve satım gerçekleşmesini istiyorsak o koşulları yazacağız.

Önceki dersimizde Yön sinyali vermiştik, şimdi bu verdiğimiz yön sinyalinin yani alım satım veya flat sinyallerinin yakalandığı ve işlemin yapıldığı yeri göstereceğim.

Aynı for döngüsü içeriside bunları yazıyoruz

/--------------- YÖN YAPILANMALARI ---------------------

if ( SonYon !="A" && Sinyal =="A" ) // AL

{

Sistem.Yon[i] = "A";

SonYon = Sistem.Yon[i];

alim = C[i];

}

//********************************

else if ( SonYon !="S" && Sinyal =="S") // SAT

{

Sistem.Yon[i] = "S";

SonYon = Sistem.Yon[i];

satım = C[i];

}

//********************************

else if ( SonYon != "F" && Sinyal =="F" ) // FLAT

{

Sistem.Yon[i] = "F";

SonYon = Sistem.Yon[i];

}

Burada ise gördüğünüz gibi Sistemin o anki yönünü alım, satım veya flat olarak belirliyoruz ve kendi belirlediğimiz SonYon değerine de aynı yön değerini veriyoruz.

Stop, algoritmik ticarette ve yatırımda önemli bir kavramdır ve bir işlemdeki potansiyel zararı sınırlandırmak için kullanılır. Stop-loss diye de geçer, stop bir pozisyonda meydana gelebilecek olumsuz fiyat hareketlerine karşı yatırımcının kendini korumasını sağlar. Stop emri, belirli bir fiyat seviyesine gelindiğinde açık olan pozisyonu otomatik olarak kapatmak amacıyla verilen bir emirdir. Biz de şimdi kendi Stop koşulumuzu yazacağız

//------------------ STOP KURALLARI ------------------------

// LONG STOP

if (SonYon =="A" && C[i] <= alim - ATRD[i] / 2 ) {

Sinyal="F";

}

//********************************

// SHORT STOP

if (SonYon =="S" && C[i] >= (satim + ATRD[i] /2 ) ) {

Sinyal="F" ;

}

Şimdi alım satım stratejilerimizi belirlememize görsel fayda sağlayabilecek bir şey öğreneceğiz, Kullanmak istediğimiz indikatörlerin grafiğimizde görünmesini sağlayacağız.

Bunun 2adımı var, önce Neyin grafiğini tutmak istiyorsak onu en üste tanımlıyoruz

/ HAREKETLİ ORTALAMALAR

var EMA8 = Sistem.MA(C, "Variable", 8);

var EMA3 = Sistem.MA(C, "Variable", 3);

bunlar hazır EMA tanımlamaları, birisi EMA8 diğeri ise EMA3 hareketli ortalamalarının değerlerini tutuyor. birde Kodun en alt kısmına

// HAREKETLİ ORTALAMA GRAFİKLERİ

Sistem.Cizgiler[0].Deger = EMA3;

Sistem.Cizgiler[1].Deger = EMA8;

değerlerini yazdıktan sonra bu sayfadan aktif edip ema değerlerini grafik olarak görebiliyoruz.

// ATRD TANIMLANMASI

var V = Sistem.GrafikVerileri;

var VG = Sistem.GrafikVerileriniOku(Sistem.Sembol,"G");

var CG = Sistem.GrafikFiyatOku(VG,"Kapanis");

//var ATRG = Sistem.AverageTrueRange(VG, 14);

var ATRG = Sistem.AverageTrueRange(VG, 14);

var ATRD = Sistem.DonemCevir(V,VG,ATRG);

ATRD = Sistem.Ref(ATRD,-1);

//------------------ STOP KURALLARI ------------------------

// LONG STOP

if (SonYon =="A" && C[i] <= alim - ATRD[i] / 2 ) {

Sinyal="F";

}

//********************************

// SHORT STOP

if (SonYon =="S" && C[i] >= (satim + ATRD[i] /2 ) ) {

Sinyal="F" ;

}

Kar al" ve "kar sat" noktaları, yatırımcıların açık pozisyonlardaki karlarını realize etmek ve belirli bir fiyat seviyesine ulaşıldığında pozisyonu kapatmak amacıyla kullandıkları stratejik noktalardır, fakat biz bunu biraz daha yorumlayıp, düşüşe geçeceğini hissedeceğimiz an olarak değiştirmeye çalışacağız.

Önce bir değişken tanımlayalım, bu değişken sürekli en yüksek değeri tutsun.

// HİGHEST

if (C[i] > Highest && SonYon== "A"){

enYuksek = C[i];

}

//********************************

// LOWEST

if (C[i] < Lowest && SonYon== "S"){

enDusuk = C[i];

}

Sonra bu değerleri kullanarak kar al ve sat noktaları belirleyelim

// KAR AL

if(SonYon =="A" && C[i] < Highest - ATRD[i-1] / 2 && C[i] > alim){

Sinyal ="F" ;

}

//********************************

// KAR SAT

if(SonYon =="S" && C[i] > Lowest + ATRD[i-1] / 2 && C[i] < satim) {

Sinyal ="F";

}

ROBOT KODU

var LotSize = 5; //işlem adedi

var SistemAdi = "xxx"; //sistemizin adı

var GrafikSembolu = "CRP'BTCUSDT_BNC"; //sistemin sinyal ürettiği grafik sembolü

var GrafikPeriyodu = "5"; //grafiğin priyodu

var EmirSembol = "CRP'BTCUSDT_BNC";

// SADECE BURDAN YUKARISI DEĞİŞTİRİLECEK, BU SATIRDAN AŞAĞISINA DOKUNULMAYACAK

var SonYon = Sistem.SonYonGetir(SistemAdi, GrafikSembolu , GrafikPeriyodu ); //sistemin adı, grafik sembolü, grafiğin periyodu

var SonFiyat = Sistem.SonFiyat(EmirSembol);

var Anahtar = Sistem.Name + "," + EmirSembol;

double IslemFiyat = 0;

DateTime IslemTarih;

var Miktar = 0.0;

var Rezerv = "";

var Pozisyon = Sistem.PozisyonKontrolOku(Anahtar, out IslemFiyat, out IslemTarih);

if (SonYon == "F" && Pozisyon != 0) // Flata Geç

Miktar = -Pozisyon;

else if (SonYon == "A" && Pozisyon != LotSize) // Al

Miktar = LotSize - Pozisyon;

else if (SonYon == "S" && Pozisyon != -LotSize) // Sat

Miktar = -LotSize - Pozisyon;

// Emir Gönder

var Islem = "";

if (Miktar > 0) {Islem = "ALIS"; Rezerv = "ALIŞ YAPILDI";}

if (Miktar < 0) {Islem = "SATIS"; Rezerv = "SATIŞ YAPILDI";}

if (Islem != "")

{

Sistem.PozisyonKontrolGuncelle(Anahtar, Miktar + Pozisyon, SonFiyat, Rezerv);

Sistem.EmirSembol = EmirSembol ;

Sistem.EmirIslem = Islem;

Sistem.EmirSuresi = "GTC";

Sistem.EmirTipi = "Piyasa";

Sistem.EmirMiktari = Math.Abs(Miktar);

Sistem.EmirGonder();

}

Hareketli ortalama, finansal piyasalarda kullanılan ve zaman içindeki fiyat değişimlerinin ortalamasını hesaplayarak trendleri belirlemeye yardımcı olan bir teknik analiz aracıdır ve belirli bir dönem içindeki fiyatların toplamının, dönem sayısına bölünmesiyle hesaplanır. Örneğin, 20 günlük hareketli ortalama, son 20 günün kapanış fiyatlarının toplamının 20'ye bölünmesiyle elde edilir. Her gün yeni bir kapanış fiyatı eklenir ve en eski kapanış fiyatı çıkarılarak güncel ortalama hesaplanır. Bu sayede, hareketli ortalama sürekli olarak güncellenir ve fiyat trendlerini takip etmek için kullanılabilir yani piyasalardaki düzensiz ve dalgalı fiyat hareketlerini düzleştirir ve daha belirgin bir trend göstergesi sağlar.

EMA (Exponential Moving Average) ve SMA (Simple Moving Average), hareketli ortalamaların iki farklı türüdür ve finansal piyasalarda trendleri belirleme ve fiyat değişimlerini düzgünleştirme amacıyla kullanılırlar.

SMA (Simple Moving Average - Basit Hareketli Ortalama):

SMA, belirli bir zaman dilimi içindeki fiyatların toplanarak zaman dilimine bölünmesiyle elde edilen bir hareketli ortalama türüdür. Her fiyatın eşit ağırlığa sahip olduğu basit bir hesaplama yöntemidir. Örneğin, 10 günlük SMA hesaplamak için son 10 günün kapanış fiyatlarının toplamı alınır ve bu değer 10'a bölünerek 10 günlük hareketli ortalama elde edilir.

EMA (Exponential Moving Average - Üssel Hareketli Ortalama):

EMA, SMA'ya benzer bir hesaplama yöntemine sahiptir, ancak farklı olarak fiyatlar arasında üssel ağırlıklandırma kullanır. Son fiyatlara daha fazla ağırlık vererek daha hızlı tepki verir ve kısa vadeli trendleri daha hassas bir şekilde yakalayabilir.

Değişken hareketli ortalama VMA3

Üssel hareketli ortalamadır. En belirgin farkı yatay piyasada fiyatlar belli bir aralıkta sıkıştığında diğer hareketli ortalamalardan daha hassas sinyal üretir. Trend oluşturmayan yatay piyasalarda daha sağlıklı sonuç verir.

EMA hesaplaması, önceki dönemlerin EMA değeri ve güncel fiyat arasında bir denge sağlar. Bu sayede, son fiyatlar daha büyük bir rol oynar ve EMA, SMA'ya göre daha hızlı ve daha duyarlı bir hareketli ortalama türüdür.

EMA'nın avantajlarından biri, fiyat trendlerini daha erken belirleyebilme yeteneğidir. Ancak, piyasalardaki hızlı ve ani dalgalanmalardan dolayı EMA'nın bazen daha fazla gürültülü olabileceği de unutulmamalıdır.

Bir grafik için hareketli ortalamaları hesaplatmak/çizdirmek için iDeal Sistem kütüphanesinde Sistem.MA fonksiyonları bulunmaktadır.

MA (Moving Average) indikatörü hesaplamak için 3 parametreyi girdi olarak vermek gerekir;

• Periyot (kaç barlık ortalama alınsın?)

• Yöntem (Hareketli ortalam hesaplama yöntemi ne olsun? (basit, üssel, ağırlılı vs.))

• Veri (hangi verilerin ortalaması alınsın? (kapanışların, yükseklerin, hacimin, bir başka indikatörün vs.)

Aşağıda gösterildiği şekilde 2 kullanım şekli vardır;

Sistem.MA(10, "Simple", "Kapanis");

Sistem.MA(Liste, "Exp", 10);

Birinci kullanım şekli, sadece yazılan kodun grafiğe uygulandığı durumlarda kullanılır ve üzerine uygulandığı grafiğin barlarının KAPANIŞ değerlerinin üssel 10 perityotluk ortalamasını hesaplar. İkinci kullanım şekli, MA’sı hesaplanmak istenen data eğer bar kapanışları eğer grafiğin barlarına ait yüksek, düşük, açılış, kapanış vs. değil de başka bir liste veya indikatör ise tercih edilir. Örneğin RSI indikatörümnün ortalaması hesaplatılacaksa bu kullanım şekli yazılır ve Liste yazan yere RSI için kullanuılan isim yazılır.

Sistem.MA(RSI, "Exp", 10);

RSI, bir varlığın belirli bir zaman dilimindeki kapanış fiyatlarının artış ve düşüşlerini karşılaştırır ve 0 ile 100 arasında bir değer üretir. 70 ve üzeri değerler aşırı alım bölgesini, 30 ve altı değerler ise aşırı satım bölgesini gösterir. RSI'nin standart periyodu 14'tür, yani son 14 günün fiyat hareketleri dikkate alınır. Ancak farklı periyotlarda da kullanılabilir.

RSI, piyasalardaki aşırı alım ve aşırı satım koşullarını belirlemek için kullanılır. Genellikle 70'in üzerindeki değerler aşırı alım bölgesini işaret eder ve fiyatların düşebileceği anlamına gelir. Benzer şekilde, 30'un altındaki değerler aşırı satım bölgesini gösterir ve fiyatların yükselebileceği sinyalini verir.

Algoritmik ticarette RSI, al-sat sinyallerinin belirlenmesinde önemli bir göstergedir. Örneğin, RSI'nin 70'i geçtiği noktada satış sinyali üretmek, aşırı alım bölgesine işaret eden bir olumsuz momentumu gösterirken, 30'un altına indiği noktada ise alım sinyali üretmek, aşırı satım bölgesine işaret eden bir olumlu momentumu gösterir.

var Rsi = Sistem.RSI(14);

Bollinger Bantları, finansal piyasalarda fiyatların olası üst ve alt sınırlarını göstermek için kullanılan bir teknik analiz aracıdır. John Bollinger tarafından geliştirilen bu gösterge, hareketli ortalamaların üst ve altına belirli bir standart sapma değeri eklenerek oluşturulur.

Bollinger Bantları, üç temel bileşenden oluşur:

Merkezi Bant (Orta Bant): Hareketli bir ortalama genellikle 20 günlük bir süre boyunca hesaplanır ve bu, merkezi bant olarak adlandırılır. Fiyatların ortalamasını gösterir ve genellikle 20 günlük SMA kullanılır.

Üst Bant (Üst Bollinger Bantı): Merkezi bantın üzerine belirli bir standart sapma değeri eklenerek oluşturulur. Bu değer genellikle 20 günlük süre boyunca fiyatların standart sapması kullanılarak hesaplanır. Üst bant, fiyatların üst sınırını ve potansiyel direnç seviyesini gösterir.

Alt Bant (Alt Bollinger Bantı): Merkezi bantın altına belirli bir standart sapma değeri eklenerek oluşturulur. Üst bant gibi alt bant da fiyatların alt sınırını ve potansiyel destek seviyesini gösterir.

Bollinger Bantları, piyasadaki volatiliteyi ve fiyat dalgalanmalarını göstermek için kullanılır. Bantlar genişlediğinde, volatilite artmış demektir ve daraldığında, piyasa daha az volatil olabilir. Bu sayede, Bollinger Bantları, potansiyel dönüş noktalarını ve trend değişimlerini tespit etmeye yardımcı olur.

Bollinger indikatörü 3 adet çizgiden oluşan bir indikatördür.

Üst, Orta ve Alt Band çizgilerinin her biri ayrı birer fonksiyon ile okutulup çağrılabilir. Ayrıca Bollinger Üst Band ile Bollinger Alt Band arasındaki farkı sunan (bandın genişliği) Bollinger Width de ayrı bir indikatör 4 gibi hesaplatılıp çağrılabilir ve kullanılabilir.

Bandın sıkıştığı veya daraldığına yönelik analizler için Width çizgisi tek başına çizdirilip yorumlanabilir.

Kullanım şekilleri aşağıdaki gibidir;

//ALT BANT Sistem.BollingerDown("Simple", 20, 2);

//ÜST BANT Sistem.BollingerUp("Simple", 20, 2);

//ORTA BANT

Sistem.BollingerMid("Simple", 20, 2);

//BANT GENİŞLİĞİ Sistem.BollingerWidth(20, 2); Sistem.BollingerWidth(Veriler,20, 2);

ATR (Average True Range), finansal piyasalardaki volatilitesini(oynaklığını) ölçmek için kullanılan bir teknik göstergedir. ATR, bir varlığın fiyat hareketlerinin ne kadar değişken olduğunu ve potansiyel fiyat hareketlerinin büyüklüğünü belirlemeye yardımcı olur. ATR, fiyatların zaman içindeki aralığını hesaplamak için yüksek, düşük ve kapanış fiyatlarını kullanır. Volatilite yüksek olduğunda ATR değeri büyür, düşük olduğunda ise ATR değeri küçülür. ATR, piyasaların hareketliliğini anlamak ve risk yönetimi stratejileri geliştirmek için yaygın olarak kullanılan önemli bir göstergedir.

Sistem.AverageTrueRange(14); Sistem.AverageTrueRange(Liste,14); Sistem.AverageTrueRange(Veriler,14);

ATRD (Average True Range Deviation), ATR'nin daha pürüzsüzleştirilmiş bir versiyonudur. ATRD, standart ATR'nin hesaplanmasında kullanılan periyot sayısını alarak daha hassas ve düzgün bir sonuç elde eder. ATRD, volatiliteyi daha net bir şekilde gözlemlemeye yardımcı olabilir ve bazı algoritmik ticaret stratejilerinde kullanılabilir.

var V = Sistem.GrafikVerileri;

var VG = Sistem.GrafikVerileriniOku(Sistem.Sembol,"G");

var CG = Sistem.GrafikFiyatOku(VG,"Kapanis");

var ATRG = Sistem.AverageTrueRange(VG, 14);

var ATRD = Sistem.DonemCevir(V,VG,ATRG);

ATRD = Sistem.Ref(ATRD,-1);

MACD (Moving Average Convergence Divergence - Hareketli Ortalama Yakınsama Sapma), finansal piyasalarda trendleri ve momentumu belirlemek için kullanılan bir osilatör göstergesidir. hareketli ortalamalar arasındaki farkı ölçerek ve bu farkın üssel hareketli ortalaması ile karşılaştırarak al-sat sinyalleri üretmeye yardımcı olur.

MACD göstergesi, üç farklı bileşenden oluşur:

Hareketli Ortalama Farkı (MACD Hattı): Kısa vadeli bir hareketli ortalama (genellikle 12 günlük) ile uzun vadeli bir hareketli ortalamanın (genellikle 26 günlük) farkıdır. Bu fark, fiyatların kısa ve uzun vadeli trendlerini gösterir.

Sinyal Hattı (Signal Line): MACD hattının üssel hareketli ortalamasıdır ve genellikle 9 günlük bir üssel hareketli ortalama kullanılır. Sinyal hattı, MACD hattının daha yumuşak ve düzgün bir çizgisini oluşturur.

Histogram: MACD hattının sinyal hattından çıkarılmasıyla elde edilen histogramdır. Histogram, al-sat sinyallerinin gücünü ve momentumu gösterir. Histogramın pozitif değerleri, kısa vadeli hareketli ortalamanın uzun vadeli hareketli ortalamayı yukarı yönlü kesmesini ve alım sinyali üretilmesini gösterir. Negatif değerler ise tam tersine düşüş trendi ve satım sinyali üretildiğini gösterir.

MACD, piyasadaki trend dönüşlerini ve momentum değişimlerini tespit etmek için kullanılır. Özellikle 0 çizgisinin üzerindeki pozitif değerler alım sinyali, 0 çizgisinin altındaki negatif değerler ise satım sinyali olarak yorumlanır.

MACD indikatörünü çağırır.

2 Adet parametre alır (varsayılan 12 ve 26) .

Aşağıdaki gibi 3 yazım şekli vardır;

Sistem.MACD(12,26);

Sistem.MACD(Liste,12, 26);

Sistem.MACD(Veriler, 12, 26);

Stokastik Osilatör (Stochastic Oscillator), finansal piyasalarda aşırı alım ve aşırı satım bölgelerini belirlemek ve trend dönüşlerini tahmin etmek için kullanılan bir momentum osilatörüdür. Dr. George Lane tarafından geliştirilen bu gösterge, fiyatların son kapanışları ile belirli bir zaman dilimindeki en yüksek ve en düşük fiyatlar arasındaki ilişkiyi değerlendirir.

Stokastik osilatör, 0 ile 100 arasında bir değer üretir ve 80'in üzerindeki değerler aşırı alım bölgesini, 20'nin altındaki değerler ise aşırı satım bölgesini gösterir. Bu bölgelerde, fiyatların ters yönde hareket etme olasılığı daha yüksektir ve trend dönüşleri beklenir.

Stochastic Fast (Hızlı Stokastik):

Stochastic Fast, belirli bir zaman dilimindeki kapanış fiyatını mevcut fiyat aralığı ile karşılaştırarak fiyatın hızlı değişimlerini ölçer. Genellikle 14 periyotluk bir zaman diliminde hesaplanır. Gösterge, 0 ile 100 arasında bir değer üretir ve bu değer, fiyatın yüksekliği ve düşüklüğü arasındaki ilişkiyi gösterir. Aşırı alım ve aşırı satım bölgeleri, 80 ve 20 seviyeleri olarak kabul edilir.

Sistem.StochasticFast(5, 3);

Stochastic Slow (Yavaş Stokastik):

Stochastic Slow, Stochastic Fast göstergesine benzer bir şekilde çalışır, ancak farklı bir hesaplama yöntemi kullanır. Hızlı Stokastik'in 3 günlük hareketli ortalamasını alarak daha pürüzsüz bir çizgi elde eder. Bu nedenle, Yavaş Stokastik daha az yanlış sinyal üretme eğilimindedir ve daha istikrarlı sonuçlar sunar. Aşırı alım ve aşırı satım bölgeleri, yine 80 ve 20 seviyeleri olarak kabul edilir.

Sistem.StochasticSlow(5,3);

Stochastic Momentum Index (Stokastik Momentum İndeksi):

Stochastic Momentum Index (SMI), Stochastic göstergesinin bir türevidir ve fiyatın momentumunu ölçer. SMI, fiyatın kapanış fiyatını mevcut fiyat aralığı ile karşılaştırarak hesaplanır. Stokastik göstergesine benzer şekilde, SMI de 0 ile 100 arasında bir değer üretir ve aşırı alım ve aşırı satım bölgeleri, 40 ve -40 seviyeleri olarak kabul edilir.

Sistem.StochasticMomIndex(5,3,3)

Stochastic Oscillator (Stokastik Osilatör):

Stochastic Oscillator, Stochastic göstergesinin daha farklı bir versiyonudur ve aşırı alım ve aşırı satım bölgelerini 0 ile 100 arasında bir skalada gösterir. 80 ve üzeri değerler aşırı alımı, 20 ve altı değerler ise aşırı satımı gösterir. Stokastik Osilatör, fiyatın momentumunu ölçer ve yatırımcılara trend değişimlerini tespit etmede yardımcı olur.

Sistem.StochasticOsc(5,3)

Bu Stochastic göstergeleri, algoritmik ticarette trendleri belirlemede, aşırı alım ve aşırı satım bölgelerini tanımlamada ve al-sat sinyalleri üretmede yaygın olarak kullanılır.

Stochastic RSI, RSI'ın fiyatın kapanış fiyatlarındaki değişimlerini ölçmek için kullanılırken, Stochastic göstergesi RSI değerlerinin belirli bir zaman dilimindeki hareketlerini izlemek için kullanılır. Böylece, Stochastic RSI, standart RSI'a göre daha pürüzsüz ve daha az gecikmeli bir gösterge sağlar.

Stochastic RSI, 0 ile 100 arasında bir değer üretir ve aşırı alım ve aşırı satım bölgelerini 80 ve 20 seviyeleri olarak kabul eder. Stochastic RSI değeri 80'in üzerine çıktığında varlık aşırı alım bölgesinde olarak kabul edilir ve fiyatların düşüş eğilimine geçebileceği düşünülür.

ADX (Average Directional Index - Ortalama Yön Endeksi), finansal piyasalarda bir varlık için trendin gücünü ve trendin yönünü belirlemek için kullanılan bir teknik analiz göstergesidir. Welles Wilder tarafından geliştirilen ADX, 0 ile 100 arasında bir değer üretir ve trendin gücüne bağlı olarak farklı seviyelerde bulunabilir.

ADX, genellikle 14 periyodluk bir süre boyunca hesaplanır ve üç bileşenden oluşur:

Pozitif Yön Hareket Endeksi (+DMI): Mevcut kapanış fiyatı ile bir önceki kapanış fiyatı arasındaki farkı ölçer ve yukarı yönlü fiyat hareketlerinin gücünü değerlendirir.

Negatif Yön Hareket Endeksi (-DMI): Mevcut kapanış fiyatı ile bir önceki kapanış fiyatı arasındaki farkı ölçer ve aşağı yönlü fiyat hareketlerinin gücünü değerlendirir.

Ortalama Yön Endeksi (ADX): +DMI ve -DMI arasındaki farkın mutlak değerinin bir süre boyunca hareketli ortalamasıdır. ADX, trendin gücünü ve yönsüz piyasa koşullarını gösterir.

ADX göstergesi, 0 ile 25 arasında olan değerler zayıf bir trendi, 25 ile 50 arasında olan değerler orta güçlü bir trendi, 50 ve üzeri olan değerler ise güçlü bir trendi gösterir. Ayrıca, ADX değeri 20'nin altında olan piyasalarda yönsüz piyasa koşulları olduğu düşünülür.

Aşağıdaki gibi 3 yazım şekli vardır; Sistem.ADX(14); Sistem.ADX(Liste, 14); Sistem.ADR(Veriler);

Borsada momentum, bir varlığın fiyatında meydana gelen hızlı ve güçlü değişiklikleri ifade eder. Momentum, fiyatın belirli bir zaman dilimindeki değişim hızını ve ivmesini ölçer. Eğer bir varlıkta yüksek momentum varsa, fiyat hızlı bir şekilde yükselme veya düşme eğilimindedir.

Momentum, teknik analizde sıkça kullanılan bir gösterge ve osilatörler arasında yer alır. Genellikle fiyatın son kapanış fiyatı ile belirli bir zaman dilimindeki önceki kapanış fiyatı arasındaki farkı hesaplayarak oluşturulur. Bu fark, pozitif veya negatif bir değer alabilir ve bu değer, fiyatın yukarı yönlü veya aşağı yönlü momentumunu gösterir.

Yüksek momentum, fiyatın güçlü bir şekilde yükseldiği veya düştüğü anlamına gelir ve trendin devam edebileceği bir sinyal olarak yorumlanır. Düşük momentum ise fiyatın yavaş veya kararsız bir şekilde hareket ettiğini gösterir ve trendin zayıflayabileceği veya ters yönde dönebileceği bir işaret olabilir.

Momentum, yatırımcılara fiyat trendlerini ve hareketlerini değerlendirmede yardımcı olur. Yüksek momentum, alım veya satım sinyallerinin güçlü olduğu anlamına gelirken düşük momentum, daha dikkatli olunması gerektiğini işaret eder.

Sistem. Momentum(12);

Sistem. Momentum(Liste,12);

Sistem. Momentum(Veriler,12);

Derinlik, finansal piyasalarda belli bir varlığın alış ve satış emirlerinin fiyat ve miktar bilgilerini gösteren bir tablodur. Derinlik tablosu, alıcıların ve satıcıların belirli bir varlık için ne kadar fiyat ve miktarla işlem yapmak istediğini gösterir.

Derinlik tablosu genellikle birkaç seviyeden oluşur. Alıcılar, varlığı daha düşük fiyattan satın almak isteyen kişileri temsil ederken, satıcılar varlığı daha yüksek fiyattan satmak isteyen kişileri temsil eder. Her seviyede, fiyat ve miktar bilgileri yan yana listelenir.

Örneğin, bir hisse senedi için derinlik tablosuna bakarsanız, en üst satırlarda en yüksek fiyatlar ve en büyük alım miktarları görünebilir. Bu, yatırımcıların o hisse senedini yüksek fiyattan almak istediklerini ve bu fiyat seviyesinde büyük bir talep olduğunu gösterir. Aynı şekilde, en alt satırlarda en düşük fiyatlar ve en büyük satış miktarları görünebilir, bu da yatırımcıların o hisse senedini düşük fiyattan satmak istediklerini ve bu fiyat seviyesinde büyük bir arz olduğunu gösterir.

var Derinlik = Sistem.DerinlikVerisiOku(Sistem.Sembol);

// TANIMLANMASI
var Gosterge = Sistem.Liste(1);

// KULLANILMA ŞEKLİ

Gosterge[i] = 100;

Gosterge[i] = 200;

// EN ALTTA GÖSTERGE OLARAK YAZDIRILMASI

Sistem.Cizgiler[4].Deger = Gosterge;

İz süren stop uygulaması, fiyat yukarı çıktıkça stop seviyesini yukarıya çeker. Fiyat geri geldiğinde ise stop seviyesi sabit kalır. Bu şekilde kar miktarını artırmaya çalışan bir uygulamadır.

// DEĞİŞKEN TANIMLAMALARI
double geciciAlim = 0;
double geciciSatim =0;

// GÜNCELLENMELERİ (FOR DÖNGÜSÜ İÇERİSİNDE)
if(C[i] > geciciAlim + ATRD[i]/2  && sonYon == "A")
geciciAlim += ATRD[i]/2;

if(C[i] < geciciSatim - ATRD[i]/2  && sonYon == "S")
geciciSatim -= ATRD[i]/2;

// STOP KURALLARI

// LONG STOP

if (SonYon =="A" && C[i] <= geciciAlim - ATRD[i-1] / 2) {

Sinyal="F";

Gosterge[i] = 25;

}

//SHORT STOP

if (SonYon =="S" && C[i] >= geciciSatim + ATRD[i-1] / 2) ) {

Sinyal="F" ;

Gosterge[i+1] =50;

}

//--------------- YÖN YAPILANMALARI ---------------------

if ( SonYon !="A" && Sinyal =="A" ) // AL

   {

   Sistem.Yon[i] = "A";

   SonYon = Sistem.Yon[i];

   geciciAlim= C[i];

}

//**

else if ( SonYon !="S" && Sinyal =="S") // SAT

   {

   Sistem.Yon[i] = "S";

   SonYon = Sistem.Yon[i];

   geciciSatim = C[i];

}

// HİGHEST - LOWEST DEĞERLERİ

double Highest = 1;

double Lowest= 1;

//--------------- HİGHEST VE LOWEST GÜNCELLENMESİ ---------------------

// HİGHEST

if (C[i] > Highest && SonYon== "A"){

Highest = C[i];

}

//**

// LOWEST

if (C[i] < Lowest && SonYon== "S"){

Lowest = C[i];

}

//--------------- KAR AL VE KAR SAT ---------------------

// KAR AL

if(SonYon =="A" && C[i] < Highest - ATRD[i-1]/2 && C[i]>alım ){

Sinyal ="F" ;

Gosterge[i+1] =75;

Highest = 0;

}

//**

// KAR SAT

if(SonYon =="S" && C[i] > Lowest + ATRD[i-1]/2 && C[i]<satım) {

Sinyal ="F";

Gosterge[i+1] =100;

Lowest = 0;

}

//------------------ EMNİYET STOPLARI------------------------

// EMNİYET LONG STOP

if (SonYon =="A" && L[i] <= tempAlim - ATRD[i-1]* 5/2 ) {

Sinyal="F";

Gosterge[i] = 125;

}

//**

// EMNİYET SHORT STOP

if (SonYon =="S" && H[i] >= (tempSatim + ATRD[i-1]* 5/2 ) ) {

Sinyal="F" ;

Gosterge[i+1] =150;

}

// Anapara bazlı kar zarar hesaplama

var gostergeAnapara = Sistem.Liste(1);

var gostergeLot = Sistem.Liste(1);

double anapara = 345000.0;

double lot     = 1;

bool alimOldu  = false;

bool tarihiGecti = false;

var baslamatarih = "20220411";

// FOR DÖNGÜSÜ İÇERİSİNDE

if (V[i].Date.ToString("yyyyMMdd") == baslamatarih ) tarihiGecti = true;

//--------------- YÖN YAPILANMALARI ---------------------

if ( SonYon !="A" && Sinyal =="A" ) // AL

   {

   Sistem.Yon[i] = "A";

   SonYon = Sistem.Yon[i];

   alım = C[i];

   geciciAlim = alım;

   Highest = alım;

   if(tarihiGecti == true){

   lot = anapara / C[i];

   anapara = 1;

   alimOldu = true;

   }

}

//**

else if ( SonYon !="S" && Sinyal =="S") // SAT

   {

   Sistem.Yon[i] = "S";

   SonYon = Sistem.Yon[i];

   satım = C[i];

   geciciSatim =satım;

   Lowest = satım;

}

//**

else if ( SonYon != "F" && Sinyal =="F" ) // FLAT

   {

   Sistem.Yon[i] = "F";

   SonYon = Sistem.Yon[i];

   if(tarihiGecti == true && alimOldu == true ){

   anapara = lot * C[i];

   lot = 1;
   alimOldu = false;

   }

   }

//ANLIK PARAYI GORME

if(SonYon == "A"){

gostergeAnapara[i] = (float) lot * C[i];

gostergeLot[i] = (float) lot;

}

if(SonYon == "F"){

gostergeAnapara[i] = (float) anapara;

}

//SADECE LONG POZİYONLARIN ÇALIŞACAĞI KOŞUL

if (EMA3[i - 1] < EMA8[i - 1] && EMA3[i] > EMA8[i])

{

karar = 1;

}

//SADECE SHORT POZİYONLARIN ÇALIŞACAĞI KOŞUL

if (EMA3[i - 1] > EMA8[i - 1] && EMA3[i] < EMA8[i])

{

karar = 2;

}

// LONG SİSTEM

if (karar == 1)

{

GostergeHangiSistem[i] = (float)1;

}

// SHORT SİSTEM

if (karar == 2)

{

GostergeHangiSistem[i] = (float)2;

}

Bir grafikte çalışma yapılan periyottan daha üst bir zaman dilimine ait barlara ait bilgileri, bu üst dönem için çizilen indikatörleri alt periyotlarda kullanmak veya çizdirmek için kullanılır. Kullanım şekli aşağıdaki gibidir; Sistem.DonemCevir(Veriler, UstDonemVerileri, UstDonemCevrilecekData); Veriler yazan yere, çalışılan periyot ne ise, o periyoda ait BAR VERİLERİ yazılır. Eğer formülde bu veriler bir değişkene atanmışsa o değişken ismi yazılır. Üst zaman diliminden alınan bilgileri değişik alt zaman periyotlarında kullanacaksak (alt dönem sabit bir periyot değilse) Veriler yazan kısma Sistem.GrafikVerileri yazılır. Bu komut, formül hangi zaman periyoduna uygulanmışsa, o zaman diliminin BAR VERİLERİNİ (OHLC tamamını birden) verir. UstDonemVerileri yazan yere, daha üst zaman dilimi olarak hangi grafik periyodu kullanılacaksa o zaman diliminin BAR VERİLERİ yazılır. Örnek: var GUNVERILER = Sistem.GrafikVerileriniOku(Sembol, “G”) diyerek GÜNLÜK BAR VERİSİ çağrılır. UstDonemCevrilecekData yazan yere, üst zaman diliminden hesaplanmış ve alt dönemde kullanılacak veya çizdirilecek veri (Fiyat veya indikatör) hangisi ise o yazılır. Örnek: Günlük, 240 dakikalık, 60 dakikalık ve 30 dakikalık periyotların 50’lik Movlarını 10 dklık grafik üzerine çizdirmek; //üst periyot verilerini

var V=Sistem.GrafikVerileri;

var V2 = Sistem.GrafikVerileriniOku(Sistem.Sembol,"60");

var C60 = Sistem.GrafikFiyatOku(V2, "Kapanis");

var EMA8_60 = Sistem.MA(C60, "Variable", 21);

var EMA3_60 = Sistem.MA(C60, "Variable", 8);

EMA8_60= Sistem.DonemCevir(V,V2, EMA8_60);

EMA3_60= Sistem.DonemCevir(V,V2,EMA3_60);

// SAHTE DEĞERLER

double sahtealim= 0;

double sahtesatim=0;

// KAR ZARAR KONTROLÜ

int zararsayaci = 0;

int sahtesayac =0;

int karsayaci =3;

if( zararsayaci <3 && karsayaci >2 ){

gerçek işlemler yapılacak, flat olduğunda kar zarar kontrolü yapacak,

eğer zarardaysa

if(zararsayaci > 2){

sahte koşullar çalışacak

// ATRD DEĞERİ

var V = Sistem.GrafikVerileri;

var VG = Sistem.GrafikVerileriniOku(Sistem.Sembol,"G");

var CG = Sistem.GrafikFiyatOku(VG,"Kapanis");

var ATRG = Sistem.AverageTrueRange(VG, 14);

var ATRD = Sistem.DonemCevir(V,VG,ATRG);

ATRD = Sistem.Ref(ATRD,-1);

//RSİ

var RSI = Sistem.RSI(10);

// SİSTEM TANIMLAMALARI

var C = Sistem.GrafikFiyatSec("Kapanis");

var L = Sistem.GrafikFiyatSec("Dusuk");

var H = Sistem.GrafikFiyatSec("Yuksek");

var O = Sistem.GrafikFiyatSec("Acilis");

var SonYon ="F";

var Sinyal = "";

double  alım = 0 ;

double  satım = 0 ;

//BOLLINGER BANTLARI

var bollingeralt= Sistem.BollingerDown("Simple", 20, 2);

var bollingerust= Sistem.BollingerUp("Simple", 20, 2);

// HAREKETLİ ORTALAMALAR

var EMA8 = Sistem.MA(C, "Exp", 8);

var EMA3 = Sistem.MA(C, "Exp", 3);

// TEMP ALIM SATIM DEĞERLERİ

double  tempAlim =0;

double  tempSatim =0;

// HİGHEST - LOWEST DEĞERLERİ

double Highest = 1;

double Lowest= 1;

// GRAFİK ELEMANLARI

var Gosterge = Sistem.Liste(1);

var tempAlimGosterge= Sistem.Liste(1);

var tempSatimGosterge = Sistem.Liste(1);

var bollingeraltg= Sistem.Liste(1);

var bollingerustg= Sistem.Liste(1);

var highestg= Sistem.Liste(1);

var lowestg = Sistem.Liste(1);

// EN YÜKSEK VE EN DÜŞÜK DEĞER

var donchianUstSistem = Sistem.HHV(20, "Kapanis");

var donchianAltSistem=  Sistem.LLV(20,"Kapanis");

float donchUst = 0;

float donchAlt = 0;

float donchOrta = 0;

for ( var i=5 ; i<Sistem.BarSayisi ; i++)

{

//if(i%20 == 0){

//}

donchUst =(float )donchianUstSistem[i-1];

donchAlt =(float )donchianAltSistem[i-1];

donchOrta = (donchUst+donchAlt)/2;

//--------------- AL VE SAT KOŞULU ---------------------

if((EMA3[i-1] <= donchAlt && EMA3[i] >= donchAlt) || SonYon != "A" && EMA3[i-1] < donchUst && EMA3[i] > donchUst ) Sinyal ="A"; // ALIM KOŞULU

//********************************

if((EMA3[i-1] >= donchUst && EMA3[i] <= donchUst) || SonYon != "S" && EMA3[i-1] > donchAlt && EMA3[i] < donchAlt )  Sinyal = "S"; // SATIM KOŞULU

//------------------ STOP KURALLARI ------------------------

// LONG STOP

if (SonYon =="A" && C[i] <= tempAlim - ATRD[i-1]*2  ) {

Sinyal="F";

Gosterge[i] = 25;

}

//********************************

//SHORT STOP

if (SonYon =="S" && C[i] >= (tempSatim + ATRD[i-1]*2 ) ) {

Sinyal="F" ;

Gosterge[i+1] =50;

}

//------------------ EMNİYET STOPLARI------------------------

// EMNİYET LONG STOP

if (SonYon =="A" && L[i] <= tempAlim - ATRD[i-1]* 5/2  ) {

Sinyal="F";

Gosterge[i] = 125;

}

//********************************

// EMNİYET SHORT STOP

if (SonYon =="S" && H[i] >= (tempSatim + ATRD[i-1]* 5/2 ) ) {

Sinyal="F" ;

Gosterge[i+1] =150;

}

//--------------- TEMP ALIM SATIM GÜNCELLENMESİ ---------------------

// TEMP ALIM

if (C[i] > tempAlim + ATRD[i-1]/2 && SonYon == "A"){

tempAlim += ATRD[i]/2;

}

//********************************

// TEMP SATIM

if (C[i] < tempSatim - ATRD[i-1]/2 && SonYon == "S"){

tempSatim -= ATRD[i]/2;

}

tempAlimGosterge[i] = (float) tempAlim;

tempSatimGosterge[i] = (float) tempSatim;

//--------------- HİGHEST VE LOWEST GÜNCELLENMESİ ---------------------

// HİGHEST

if (C[i] > Highest && SonYon== "A"){

Highest = C[i];

}

//********************************

// LOWEST

if (C[i] < Lowest && SonYon== "S"){

Lowest = C[i];

}

//--------------- YÖN YAPILANMALARI ---------------------

if ( SonYon !="A" && Sinyal =="A" ) // AL

   {

   Sistem.Yon[i] = "A";

   SonYon = Sistem.Yon[i];

   alım = C[i];

   tempAlim = alım;

   Highest = alım;

   }

//********************************

else if ( SonYon !="S" && Sinyal =="S") // SAT

   {

   Sistem.Yon[i] = "S";

   SonYon = Sistem.Yon[i];

   satım = C[i];

   tempSatim=satım;

   Lowest = satım;

}

//********************************

else if ( SonYon != "F" && Sinyal =="F" ) // FLAT

   {

   Sistem.Yon[i] = "F";

   SonYon = Sistem.Yon[i];

   }

//--------------- KAR AL VE KAR SAT ---------------------

// KAR AL

if(SonYon =="A" && C[i] < Highest - ATRD[i-1]*2 && C[i]>alım ){

Sinyal ="F" ;

Gosterge[i+1] =75;

Highest = 0;

}

//********************************

// KAR SAT

if(SonYon =="S" && C[i] > Lowest + ATRD[i-1]*2 && C[i]<satım) {

Sinyal ="F";

Gosterge[i+1] =100;

Lowest = 0;

}

}

//--------------- GRAFİKLER ---------------------

// HAREKETLİ ORTALAMA GRAFİKLERİ

Sistem.Cizgiler[0].Deger = EMA3;

Sistem.Cizgiler[1].Deger = EMA8;

// ATRD GRAFİĞİ

Sistem.Cizgiler[3].Deger = ATRD;

// DEĞİŞKEN GÖSTERGE

Sistem.Cizgiler[4].Deger = Gosterge;

Sistem.Cizgiler[9].Deger = bollingeraltg;

Sistem.Cizgiler[10].Deger = bollingerustg;

//------------------ ZAMAN STOPLARI------------------------

// ZAMAN LONG STOP

if (SonYon =="A" && barsayaci > 20 && C[i] < alım * 1.01 ) {

Sinyal="F";

Gosterge[i] = 200;

}

//********************************

// taranacak periyot kadar döngü açın

// kalitesiz kodlama yaparsanız hesaplama süresi çok uzun olabilir

for (double N=10 ; N<40 ; N+=1){

Sistem.Optimizasyon("ATRD  =  ",N);

}