تعال وتعلم معنا لغة MQL4 حتى الاحتراف

[وضاح عطار]

بسم الله الرحمن الرحيم

تعلمنا في الدروس السابقة كل الأساسيات اللازمة لعمل فكرة مؤشرنا الجديد.

بقي عندنا مفهوم واحد فقط ( ضروري لهذه المرحلة ) لم نشرحه حتى الآن وهو مفهوم الحلقات Loops.

والحلقات ببساطة هي عبارة عن كتلة برمجية يتم تنفيذها عدد محدد من المرات.

أي أن هذه الكتلة البرمجية سوف تنفذ n مرة بحيث n هي العدد المطلوب لتكرار تنفيذ هذه الكتلة البرمجية.

عناصر الحلقة البرمجية:

- متحول رقمي ( عداد ) قد يكون من النوع int أو من النوع double فقط.

- شرط استمرار الحلقة وهو الشرط اللازم تحققه لاستمرار الحلقة. وبمجرد عدم تحقق الشرط للمرة الأولى يتم الخروج من الحلقة.

- مقدار التزايد في عداد الحلقة في كل مرة يتم تنفيذ الكتلة البرمجية للحلقة.

أمر الحلقة هو for وله ثلاثة بارامترات من نوع خاص.

- البارامتر الأول هو متحول العداد الرقمي وقيمة ابتدائية له.

- البارامتر الثاني هو شرط استمرار الحلقة.

- البارامتر الثالث هو مقدار التزايد في عداد الحلقة كل مرة.

هذه ليست بارامترات بالمعنى الحقيقي للبارامترات ولكنها عبارة عن أوامر برمجية.

لذلك يتم الفصل بينها بالفاصلة المنقوطة وليس بالفاصلة العادية فانتبه لهذا الأمر.

هذه الأمثلة سوف توضح بالضبط كل الحالات الممكنة لانشاء حلقة.

مثال (1)

 for (int i=1;i<=10;i++)
{
Print(i);
} 
  

الحلقة السابقة تعرف العداد على أنه متحول رقمي صحيح يبدأ من الواحد.

شرط استمرار الحلقة هو أن تكون قيمة المتحول أصغر من أو تساوي العشرة.

العداد i سوف يزداد واحد كل مرة يتم تكرار تنفيذ الكتلة البرمجية الموجودة داخل الأقواس المعقوفة.

وفي داخل الكتلة البرمجية للحلقة سوف تتغير قيمة المتحول العداد i لتأخذ القيمة الحالية ( أي تكون أول مرة واحد ثم تصبح اثنان وهكذا).

هذا يعني أن حلقتنا سوف تبدأ من الواحد وحتى العشرة أي أنها ستنفذ عشرة مرات فقط.

لأنه بمجرد ان تصبح قيمة العداد 11 سوف لن يتحقق شرط تنفيذ الحلقة.

وعندها سينتقل التنفيذ البرمجي لما بعد الكتلة البرمجية للحلقة.

مثال (2)

 for (int i=5;i<=100;i++)
{
Print(i);
} 
  

مشابهة للمثال الأول ولكن البداية ستكون من الخمسة والنهاية عند 100.


مثال (3)

 for (int i=0;i<50;i=i+2)
{
Print(i);
} 
  

الحلقة السابقة تبدأ من الصفر وتنتهي بالخمسين وزيادة العداد ستكون اثنان اثنان في كل مرة وليس واحد واحد.


مثال (4)

 for (int xx=10;xx>0;xx--)
{
Print(xx);
} 
  

المثال السابق لحلقة عكسية تبدأ من العشرة وتنتهي بالواحد ( لاحظ الشرط كيف أصبح )

ولاحظ أيضا كيف أننا جعلنا العداد يتناقص ولا يتزايد.

وطبعا اسم المتحول هو اختياري ولكن جرى العرف البرمجي أن يكون اسمه i .

مثال (5)

 for (double i=0.1;i<=1;i=i+0.1)
{
Print(i);
} 
  

في الحلقة السابقة جعلنا العداد متحول رقمي بفاصلة عائمة عشرية تبدأ من القيمة 0.1 وتنتهي بالواحد وتتزايد بمقدار 0.1 كل مرة.



مثال (6)

 double i;
for (i=0.1;i<=1;i=i+0.1)
{
Print(i);
} 
  

المثال السابق نفس الذي يسبقه تماما ولكني عرفت المتحول من خارج جسم الحلقة وليس من داخل الحلقة.


يمكن وضع حلقة داخل حلقة بمعنى أنه يمكنك وضع حلقة كاملة مع كتلتها البرمجية داخل كتلة برمجية لحلقة أكبر.

كما يمكن أن تكون الحلقة بعدادين أو أكثر. لأن الحلقات مرنة جدا جدا ومعقدة جدا جدا.

ولكن لا أريد منكم الآن إلا أن تفهموا أبسط استخدام للحلقات البسيطة.

[وضاح عطار]

بعد أن شرحنا مفهوم الحلقات البرمجي يمكننا الآن أن نستمر في بناء مؤشرنا الجديد.

لنراجع آخر كود وصلنا إليه:

 //+------------------------------------------------------------------+
//|                                                Candle Length.mq4 |
//|                               Copyright © 2006, eng waddah attar |
//|                                               www.****quotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, eng waddah attar"
#property link      "http://www.****quotes.net"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
double BufLength1[];
double BufLength2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
  SetIndexBuffer(0,BufLength1);
  SetIndexBuffer(1,BufLength2);
  SetIndexStyle(0,DRAW_HISTOGRAM);
  SetIndexStyle(1,DRAW_HISTOGRAM);
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
//----
   return(0);
  }
//+------------------------------------------------------------------+ 
  

الآن سنضيف الحلقة الرئيسية للمؤشر ومهمة هذه الحلقة هي المرور على كل الشمعات على الشارت وحساب قيم مؤشرنا عند كل شمعة.

وبالتالي سوف تظهر خطوط المؤشر على الشارت.

الحلقة ستكون على الشكل التالي:

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

كل شيء معروف لكن هناك المتحول الجديد Bars والذي هو عبارة عن متحول جاهز ضمن اللغة نفسها.

في هذا المتحول Bars تخزن قيمة رقمية صحيحة تمثل عدد الشموع على الشارت الذي وضعنا عليه مؤشرنا.

ولا نحتاج لتعريف المتحول Bars لأنه معرف داخليا مع قيمة تمثل عدد الشموع.

في الحلقة السابقة نحن نقول للبرنامج أن ينفذ الكتلة البرمجية للحلقة بدءا من القيمة صفر وحتى آخر شمعة موجودة على الشارت.

سوف نضيف جسم الحلقة إلى الكود ونحذف السطر:

 int counted_bars=IndicatorCounted(); 
  

لأننا سنشرحه فيما بعد.


والآن سنضيف كتلة الحلقة البرمجية والتي من خلالها سنحسب قيم مؤشرنا لعرضها على الشارت.

نحن نريد حساب طول الشمعة أي الفرق بين الهاي واللو.
ولذلك فإن قيمة المصفوفة الأولى ستكون:

 BufLength1[i]=High[i]-Low[i]; 
  

أي أننا سنضع في الحجرة الأولى للمصفوفة BufLength1 وهي التي لها رقم صفر.

الفرق بين قيمة الهاي واللو للشمعة رقم صفر.

وكما وضحنا سابقا فإن المصفوفة High والمصفوفة Low هي مصفوفات جاهزة وفيه قيم الشمعات الموجودة على الشارت الحالي.

ستصبح الحلقة على الشكل التالي:

 for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
   } 
  

وسيصبح المثال على الشكل التالي :

 //+------------------------------------------------------------------+
//|                                                Candle Length.mq4 |
//|                               Copyright © 2006, eng waddah attar |
//|                                               www.****quotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, eng waddah attar"
#property link      "http://www.****quotes.net"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
double BufLength1[];
double BufLength2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
  SetIndexBuffer(0,BufLength1);
  SetIndexBuffer(1,BufLength2);
  SetIndexStyle(0,DRAW_HISTOGRAM);
  SetIndexStyle(1,DRAW_HISTOGRAM);
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
 
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
   for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
   }
//----
   return(0);
  }
//+------------------------------------------------------------------+ 
  

[wajdyss]

جزاك الله كل خير

[وضاح عطار]

بسم الله الرحمن الرحيم

في هذا الدرس سنتكلم عن الشروط Conditions وكيفية معالجتها والتعامل معها برمجيا.

ولكن قبل البدء سنتكلم نظريا لاستيعاب الفكرة الأساسية للشروط ومفهمومها البرمجي.

الشرط هو عبارة عن مقارنة رياضية بين قيمتين رقميتين أو نصيتين.

والمقارنات الرياضية هي نفسها المعروفة للجميع وهي:

- يساوي ويرمز لها بالرمز ( == ).

- لا يساوي ويرمز لها بالرمز ( =! ).

- أكبر من ولها الرمز ( < ).

- أصغر من ولها الرمز ( > ).

- أكبر من أو يساوي ( =< ).

- أصغر من أو يساوي ( => ).

بحيث يتم وضع العلاقات السابقة بين متحولين أو قيمتين على الشكل التالي:

(A==B) \\ الشرط هو أن تكون قيمة المتحول A تساوي قيمة المتحول B.

(A>=5) \\ الشرط هو أن تكون قيمة المتحول A أكبر من أو تساوي الخمسة.

(GetNum()!=old) \\ الشرط هو أن تكون القيمة العائدة من الوظيفة GetNum لا تساوي قيمة المتحول old .

('AccName=='khaled) \\ الشرط هو أن تكون قيمة المتحول AccName هو القيمة النصية khaled.


تتم معالجة الشرط عند التنفيذ كما يلي:

- يقوم البرنامج باستبدال المتحولات بقيمها لحظة التنفيذ في عبارة الشرط.

- ثم يقوم بالمقارنة الرياضية بين القيم.

- عند تحقق الشرط يضع القيمة صح true.

- عند عدم تحقق الشرط يضع القيمة خطأ false.

مثال:

لدينا مثلا الشرط (A==B) بحيث كانت قيمة A تساوي 4 وقيمة B تساوي 4 لحظة تنفيذ عبارة الشرط.

يقوم منفذ التعليمات البرمجية باستبدال المتحولات بقيمها ليصبح الشرط (4==4).

ثم يقوم بالمقارنة الرياضية ليجدها صحيحة ويضع قيمة true.
وتصبح عبارة الشرط (A==B) تصبح (true).

طبعا المعالجة السابقة تتم في الذاكرة وليس على نص البرنامج الأصلي.

مما سبق نريد أن نقول أن أي شرط يتحول في نهاية المطاف إلى قيمتين فقط هما true في حال كان الشرط صحيحا أو false في حال كان الشرط خاطئا.


الشرح السابق الهدف منه هو شرح كيفية تعامل منفذ الأوامر مع الشروط وأيضا هو تمهيد لشرح أمر آخر وهو العلاقات المنطقية Booleans بين الشروط نفسها.

في الشرح السابق تكلمنا عن عبارة تحوي شرطا واحدا فقط.
ولكننا قد نحتاج إلى فحص شرطين أو أكثر في نفس الوقت.
أي أن عبارة الشرط تتكون من عدة شروط تحكمها علاقات منطقية بووليانية.

ما هي العلاقات المنطقية البووليانية؟

لدينا ثلاثة علاقات منطقية أساسية هم:

- العلاقة ( و ) AND ويرمز لها برمجيا بالرمز && .

- العلاقة ( أو ) OR ويرمز لها برمجيا بالرمز || .

- العلاقة ( عكس ) NOT ويرمز لها برمجيا بالرمز ! .

العلاقة AND ببساطة تعني أنه يجب تحقق كل الشروط الفرعية ليصبح الشرط النهائي محققا.

العلاقة OR تعني أنه يكفي تحقق أحد الشروط الفرعية ليصبح الشرط النهائي محققا.

العلاقة NOT تعني أنه يجب عدم تحقق الشروط الفرعية ليتحقق الشرط النهائي.

أمثلة توضيحية:

لدينا مثلا شرطان الأول هو (A==B) والثاني هو (B>=5).
ونريد أن ندمج هذين الشرطين في شرط واحد بحيث نريد تحقق كلا الشرطين معا.

لتصبح العبارة الشرطية على الشكل التالي:

(A==B) && (B>=5)

أما إذا أردنا تحقق أحد الشرطين فقط فإن العبارة الشرطية تصبح على الشكل التالي:

(A==B) || (B>=5)

أما إذا كان شرطنا الأساسي هو عدم تحقق كلا الشرطين فإن العبارة تصبح:

((A==B) && (B>=5))!

والحالة الأخيرة هي إذا كان شرطنا الأساسي هو عدم تحقق أحد الشرطين فإن العبارة تصبح:

((A==B) || (B>=5))!

قد يحصل معكم لبس قليل في حالة المقارنة المنطقية NOT ولكنها ستزول بعد فترة.

لذلك كل ما أريده منكم أن يكون مفهوم العلاقات الرياضية بين القيم الرقمية أو النصية وكذلك مفهوم العلاقات المنطقية بين الشروط مفهومين بشكل نظري على الأقل.

بالنسبة للعلاقات الرياضية بين القيم الرقمية فهي مفهومة كأن تكون 6 أكبر من 3.

ولكن تطبيق العلاقات الرياضية بين النصوص قد يشكل لبسا لديكم ولكن الأمر بسيط أيضا.

فالمساواة بين النصوص هي أن تكون النصوص متساوية حرفيا.

أما علاقات الأكبر والأصغر فهي تعني الترتيب الأبجدي فمثلا الحرف a أصغر من الحرف b وهكذا.

[وضاح عطار]

الأمر الذي يعالج الشروط وينفذ الأوامر البرمجية بناء على نتائج هذه الشروط هو الأمر if ويتم وضع كل الشروط داخل قوسين () .

في حال تحقق الشرط فإن منفذ الأوامر سوف ينفذ الكتلة البرمجية المرتبطة بالأمر if.

يمكن إضافة كتلة برمجية أخرى للأمر if تأتي بعد الأمر else وهي تعني في حال عدم تحقق شروط if فيجب تنفيذ الكتلة البرمجية التابعة للأمر else.

وتكون الصيغة البرمجية للأمر if كما يلي:

 if(A==B)
{
 الكتلة البرمجية للأمر if
} 
  

أو مع وجود أمر else

 if(A==B)
{
 الكتلة البرمجية للأمر if
}
else
{
 الكتلة البرمجية للأمر else
} 
  

الأمر else وكتلته البرمجية أمر خياري يعني يمكن عدم كتابته أصلا. وهذا راجع لاحتياجات المبرمج وطريقة برمجته.


عودة لمؤشرنا ولنتذكر هنا آخر كود وصلنا إليه:

 //+------------------------------------------------------------------+
//|                                                Candle Length.mq4 |
//|                               Copyright © 2006, eng waddah attar |
//|                                               www.****quotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, eng waddah attar"
#property link      "http://www.****quotes.net"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
double BufLength1[];
double BufLength2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
  SetIndexBuffer(0,BufLength1);
  SetIndexBuffer(1,BufLength2);
  SetIndexStyle(0,DRAW_HISTOGRAM);
  SetIndexStyle(1,DRAW_HISTOGRAM);
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
   for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
   }
   return(0);
  }
//+------------------------------------------------------------------+ 
  

لقد جعلنا المؤشر يقوم برسم خطوط عمودية تمثل طول الشمعة الحالية.

وبما أن الطول هو عبارة عن الفرق بين الهاي واللو فهذا يعني أنه موجب دائما.

ولكن طول جسم الشمعة بما أنه الفرق بين الإغلاق والفتح فهذا يعني أنه قد يكون موجبا أو سالبا.

وبما أننا خططنا لمؤشرنا أن يرسم خطي الطول فهذا يعني أن يكون كلا الطولين موجبا دائما.

ولذلك سنطبق ما تعلمناه عن الشروط لمعالجة هذا الأمر وذلك لرسم الخط الثاني بشكل موجب وصحيح دائما.

بشكل بسيط سوف نحسب طول جسم الشمعة على أنه الفرق بين الإغلاق والفتح.

في حال كان الإغلاق أكبر من الفتح فهذا يعني أن الطول سيكون موجبا وهو الحالة الصحيحة الأولى.

في حال كان الإغلاق أصغر من الفتح فهذا يعني أن الطول سيصبح سالبا ولذلك يجب تغيير كيفية حساب الطول إلى الفتح ناقص الإغلاق.

طبعا يمكن معالجة هذه الحالة برمجيا بعدة طرق سنستعرض معظمها لزيادة الشرح والفهم.

وأي طريقة منها تعطينا النتيجة الصحيحة فهي صحيحة بالنهاية.

ويعود اختيار أحدها إلى المبرمج نفسه وطريقة تفكيره ومعالجته للأمر.

الطريقة الأولى:

وضع الشرط والحساب في كتلة برمجية واحد تتضمن if و else كالتالي:

 if(Close[i]>Open[i])
{
BufLength2[i]=Close[i]-Open[i];
}
else
{
BufLength2[i]=Open[i]-Close[i];
} 
  

المثال السابق يقول في حال كان الإغلاق أكبر من الفتح فإن طول الشمعة يساوي الإغلاق ناقص الفتح.

وإلا ( else ) في حال عدم تحقق الشرط أي أن الإغلاق أصغر من أو يساوي الفتح فإن طول الشمعة يساوي الفتح ناقص الإغلاق.

وتصبح كتلة الوظيفة start كالتالي:

 int start()
  {
//----
   for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
     if(Close[i]>Open[i])
     {
       BufLength2[i]=Close[i]-Open[i];
     }
     else
     {
       BufLength2[i]=Open[i]-Close[i];
     }
   }
   return(0);
  } 
  

الطريقة الثانية:

حساب طول جسم الشمعة دائما على أنه الإغلاق ناقص الفتح وفي حال كان الطول سالبا نضرب النتاتج في -1 ليصبح موجبا ويكون الكود كالتالي:

 LL=Close[i]-Open[i];
     if(LL<0)
     {
       LL=-1*LL;
     }
     BufLength2[i]=LL; 
  

وتصبح كتلة الوظيفة start كالتالي:

 int start()
  {
//----
   double LL;
   
   for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
     
     LL=Close[i]-Open[i];
     if(LL<0)
     {
       LL=-1*LL;
     }
     BufLength2[i]=LL;
   }
   return(0);
  } 
  

[وضاح عطار]

الطريقة الثالثة:

في هذه الطريقة سنستخدم الوظائف الحسابية المتوفرة في لغة MQL4 والتي تسهل علينا كثيرا القيام بعمليات حسابية دون الخوض بطريقة عملها الداخلية.

الوظيفة التي سنستخدمها هي الوظيفة MathAbs وهي تعطينا القيمة المطلقة ( الموجبة ) لأي رقم سالب أو موجب.

المدخلات لهذه الوظيفة هي الرقم الذي نريد حساب القيمة المطلقة له.
والمخرجات هي القيمة المطلقة.

مثال:

 Print(MathAbs(-5));
 سيتم طباعة 5 
  

 Print(MathAbs(7));
 سيتم طباعة 7 
  

وباستخدام الوظيفة MathAbs نكون قد استغنينا عن الشرط الذي وضعناه سابقا

ويصبح الكود على الشكل التالي:

 //+------------------------------------------------------------------+
//|                                                Candle Length.mq4 |
//|                               Copyright © 2006, eng waddah attar |
//|                                               www.****quotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, eng waddah attar"
#property link      "http://www.****quotes.net"
#property indicator_separate_window
#property indicator_buffers 2
#property indicator_color1 Green
#property indicator_color2 Red
double BufLength1[];
double BufLength2[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
{
  SetIndexBuffer(0,BufLength1);
  SetIndexBuffer(1,BufLength2);
  SetIndexStyle(0,DRAW_HISTOGRAM);
  SetIndexStyle(1,DRAW_HISTOGRAM);
  return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
//----
   for(int i=0;i<Bars;i++)
   {
     BufLength1[i]=High[i]-Low[i];
     BufLength2[i]=MathAbs(Close[i]-Open[i]);
   }
   return(0);
  }
//+------------------------------------------------------------------+ 
  

ولن يهمنا عندا هل الإغلاق أكبر من الفتح أم الفتح أكبر من الإغلاق


والطرق الثلاث تعطي نفس النتائج.

[وضاح عطار]

سنتعرف أكثر عن الوظائف الحسابية المتوفرة في لغة MQL4
مع ملاحظة أن كل الوظائف الحسابية تبدأ بالاسم Mathxxxx

الوظيفة MathAbs لحساب القيمة المطلقة .

الوظيفة MathCos لحساب قيمة Cosine الزاوية ( خاصة بعلم المثلثات ).

الوظيفة MathSin لحساب قيمة Sine الزاوية ( خاصة بعلم المثلثات ).

الوظيفة MathTan لحساب قيمة Tan الزاوية ( خاصة بعلم المثلثات ).

الوظيفة MathArccos لحساب قيمة Arc Cosine الزاوية ( خاصة بعلم المثلثات ).

الوظيفة MathArcsin لحساب قيمة Arc Sine الزاوية ( خاصة بعلم المثلثات ).

الوظيفة MathArctan لحساب قيمة Arc Tan الزاوية ( خاصة بعلم المثلثات ).

وهي كلها معروفة لنا وقد درسناها في المرحلة الثانوية ولكن تسميتها تختلف من دولة لأخرى.

نحن عندنا في سورية نرمز لها ( جب - تجب - ظل ... الخ )
في السعودية كما أذكر يرمزون لها ( جا - جتا - ظا - ظتا ... الخ )

بالنسبة لي لم أستخدم هذه الوظائف في برمجتي أبدا لأني حتى الآن لم أجد استراتيجية أو طريقة تحتاج مثل هذه الحسابات.

الوظيفة MathLog لحساب قيمة اللوغاريتم ( خاصة بعلم المثلثات ).

الوظيفة MathCeil تقوم بحساب أكبر قيمة صحيحة للرقم المدخل ( 5.5 تصبح 6 و -5.5 تصبح -5 )

الوظيفة MathFloor تقوم بحساب أصغر قيمة صحيحة للرقم المدخل ( 5.5 تصبح 5 و -5.5 تصبح -6 )

الوظيفة MathMin تعيد القيمة الصغرى للقيمتين المدخلتين للوظيفة نفسها.

الوظيفة MathMax تعيد القيمة الكبرى للقيمتين المدخلتين للوظيفة نفسها.

الوظيفة MathPow تعيد قيمة الرقم مضروب بنفسه عدد محدد من المرات.

مثال:
MathPow(3,2)
سوف تعطينا النتيجة 3×3 = 9

MathPow(4,3)
سوف تعطينا النتيجة 4×4×4= 64

الوظيفة MathRand تعطينا دائما رقم عشوائي متغير من 0 - 32767

الوظيفة MathRound تقوم بتقريب الرقم إلى أقرب رقم صحيح ( 2.3 تصبح 2 و 2.6 تصبح 3 )

الوظيفة MathSqrt تقوم بحساب الجذر التربيعي للرقم المدخل.

كل الوظائف الحسابية السابقة مدخلاتها عبارة عن الرقم الذي نريد حساب الشيء عليه والخرج دائما هو النتيجة.

[وضاح عطار]

الوظيفة MathRound تقرب الأرقام العشرية

بمعنى إذا كانت الأرقام العشرية أكبر أو تساوي 0.5 فإنها تزيد الرقم واحدا.

مثلا الرقم 2.6 تصبح 3 لأن الرقم العشري أكبر من 0.5

ولكن 2.4 تصبح 2 لأن الرقم العشري أصغر من 0.5


الوظيفة MathFloor تزيل الرقم العشري ولا تقربه .

وتحول الرقم إلى الرقم الأصغر

مثلا 8.9 تصبح 8

و -4.2 تصبح -5 على اعتبار أن -5 هي الرقم الأصغر وليس -4


كل وظيفة تعمل بنظام مختلف ولكن ليسوا عكس بعض

[وضاح عطار]

سنضيف بعض البهارات إلى مؤشرنا لمزيد من الإحاطة.

أولا: تقييد مجال عرض قيم المؤشر:

بما أن المؤشر له قيم موجبة فقط فما رأيكم لو جعلناه يبدأ من الصفر تماما بحيث تظهر الخطوط مباشرة من أسفل النافذة
دون وجود هامش.

هذا الأمر مسؤول عنه خاصية للمؤشر هي indicator_minimum وهي تحدد القيمة الصغرى لمجال عرض القيم على المؤشر.

يمكن طبعا للمستخدم التحكم يدويا في هذه القيمة من خلال خصائص المؤشر نفسها.

ولكن إعطاء قيمة افتراضية لهذه الخاصية يزيد مؤشرنا قوة وسهولة.

والآن سنضيف الخاصية الجديدة لمؤشرنا أعلى الكود مع باقي الخصائص الأخرى على الشكل التالي:

 #property indicator_minimum 0 
  

نكتب اسم الخاصية ثم مسافة ثم القيمة ولا نضع أي فواصل من أي نوع.

بالمناسبة فإن هناك خاصية مكملة لهذه الخاصية وهي تحدد المجال الأكبر للمؤشر على النافذة وهي indicator_maximum.

ويتم إعطاء قيمة لهذه الخاصية بنفس الطريقة السابقة تماما.
ولكن مؤشرنا لا يحتاج لهذه الخاصية لأن المجال الموجب مفتوح ولا نعرف أقصى قيمة ستكون عليه طول الشمعات.

ولذلك لم نستخدم هذه الخاصية وشرحناها فقط لإكمال الفكرة.


ثانيا: إضافة مستويات جاهزة للمؤشر:

سنضيف أيضا في مؤشرنا الجديد بعض المستويات ( يستطيع أي مؤشر أن يحتوي حتى 8 مستويات فقط )

والمستوى هو خط أفقي يتم رسمه على نافذة المؤشر وأيضا يستطيع المستخدم التحكم بهذه المستويات من خلال خصائص المؤشر.

يتم إضافة مستويات للمؤشر عن طريق الخصائص indicator_level1 و indicator_level2 و indicator_level3 وهكذا حتى indicator_level8.

ويتم تحديد قيمته على الشكل التالي:

 #property indicator_level1 0.0020 
  

الكود السابق أضاف لنا مستوى عند القيمة 0.0020 للمؤشر أي عند مستوى 20 نقطة.

كم يمكننا إضافة مستوى آخر عند القيمة 0.0040 مثلا بواسطة الكود:

 #property indicator_level2 0.0040 
  

كما يمكن لنا بواسطة الخصائص indicator_levelcolor و indicator_levelwidth و indicator_levelstyle التحكم بلون وسماكة وطريقة رسم المستويات على التوالي.

طرق عرض المستويات هي لكل المستويات مجتمعة وليست لكل مستوى على حدة.


كما يرجى ملاحظة أن بعض التغييرات في بعض الخصائص قد يضطرك إلى إزالة المؤشر من على الشارت ثم إعادته من جديد لتظهر هذه التغييرات.

[wajdyss]

جزاك الله كل خير

[shadoon2]

جزاك الله خيرا أخي وضاح على جهدك ووقتك ووفقك الله إلى ما تحب وترضى
ولكن .........................
بدأ اليأس يدب إلى قلبي ..أنت قلت أبسط مؤشر وأنا أجده من الصعوبة ليس بقليل
فكيف إذا بالمؤشرات المعقدة أو مافي رؤوسنا من أفكار للمؤشرات والأكسبيرتات ....؟
عايزين منك كلمتين تشجيع
كأن تقول لنا شدوا الهمة يا شباب كلها عشر سنين وتصيروا مبرمجين ؟
شو رأيك..أنا بصراحة شكلي ولا بعشر سنين ممكن أتعلم البرمجة بس رح أتابع الكفاح ومشكور مجددا على هذه الدورة القيمة ...أخوك أبو فاضل ...

[وضاح عطار]

جزاك الله كل خير

أهلا بك أخي الفاضل

أرجو أن تكون قد استفدت من هذه الدروس حتى الآن .

بالتوفيق إن شاء الله

[وضاح عطار]

جزاك الله خيرا أخي وضاح على جهدك ووقتك ووفقك الله إلى ما تحب وترضى
ولكن .........................
بدأ اليأس يدب إلى قلبي ..أنت قلت أبسط مؤشر وأنا أجده من الصعوبة ليس بقليل
فكيف إذا بالمؤشرات المعقدة أو مافي رؤوسنا من أفكار للمؤشرات والأكسبيرتات ....؟
عايزين منك كلمتين تشجيع
كأن تقول لنا شدوا الهمة يا شباب كلها عشر سنين وتصيروا مبرمجين ؟
شو رأيك..أنا بصراحة شكلي ولا بعشر سنين ممكن أتعلم البرمجة بس رح أتابع الكفاح ومشكور مجددا على هذه الدورة القيمة ...أخوك أبو فاضل ...

أهلا بأخي الفاضل أبو فاضل

لن أشجعك مجرد تشجيع بل سأذكر لك حقائق فقط .

أولا اليأس عدو العلم الأول .

ثانيا تعلم البرمجة مثل الحفر بالصخر .

ثالثا لكن القليل من التركيز والصبر كل يوم يقلب الموازين لصالحك .

رابعا بمجرد فهم واستيعاب بداية الموضوع ووضع رجلك على أول درجة بشكل سليم يبدأ الانطلاق بشكل لم تكن تتوقعه .

خامسا حسب خبرتي في البرمجة فأنا أشبهها على أنها سلم أول ثلاث درجات لفوق بعدين كل درجاته لأسفل .

يعني الصعوبة فقط تكون في البداية بعدها يكون التعلم والمتابعة غاية في السهولة .


بالتوفيق للجميع إن شاء الله

[shadoon2]

أهلا بأخي الفاضل أبو فاضل

لن أشجعك مجرد تشجيع بل سأذكر لك حقائق فقط .

أولا اليأس عدو العلم الأول .

ثانيا تعلم البرمجة مثل الحفر بالصخر .

ثالثا لكن القليل من التركيز والصبر كل يوم يقلب الموازين لصالحك .

رابعا بمجرد فهم واستيعاب بداية الموضوع ووضع رجلك على أول درجة بشكل سليم يبدأ الانطلاق بشكل لم تكن تتوقعه .

خامسا حسب خبرتي في البرمجة فأنا أشبهها على أنها سلم أول ثلاث درجات لفوق بعدين كل درجاته لأسفل .

يعني الصعوبة فقط تكون في البداية بعدها يكون التعلم والمتابعة غاية في السهولة .


بالتوفيق للجميع إن شاء الله

مشكور على ردك وتشجيعك أخي العزيز وضاح وأنا لم أقصد إلا شيئا من المزاح حتى يحلى جو الدورة
وأنا متابع معك للنهاية إن شاء الله .

[wajdyss]

أهلا بك أخي الفاضل

أرجو أن تكون قد استفدت من هذه الدروس حتى الآن .

بالتوفيق إن شاء الله

أخ وضاح

أنا مهندس ومبرمج كمبيوتر

و لي معرفة جيدة ببعض لغات البرمجة الاخرى

وقد استفدت جداً من دروسك (بارك الله فيك)


وقد بدأت فعلاً بعمل بعض الاكسبيرتات البسيطة

والفضل في ذلك يعود لله أولاً ثم لبعض الاخوة هنا ومنتديات الجيران

جزاكم الله جميعاً كل خير

وان شاء الله اواصل تعلم هذه اللغة للوصول للاحتراف

وان شاء الله استطيع ان ارد لكم الجميل بمساعدة الاخوة في عمل المؤشرات والاكسبيرتات في المستقبل