Помогите разобратся (проблема с вычислением "равнопунктовых" баров)

Новый комментарий
 

   Здравствуйте!
Есть одна идея, для её реализации нужно учитывать только изминение цены (наподобие пункто-цыфровых графиков). Ну вот взялся написать
сначала скрипт, который записывает изминение цены в масив, в виде 1 и 0, тоесть если цена достигла некоторый limit, то записываем 1 или 0,
в зависимости от направления, и передвигаем ценовую метку st. Всё вроде бы хорошо, но не пойму почему иногда не сробатывает условие
High[i]>=st+limit или Low[i]<=st-limit когда High или Low достигают лимита, а иногда сробатывает, и что самое главное всегда сробатывает,

когда High или Low > лимита, но я ведь везде написал >= и <=. Помогите пожалуйста разобратся. Возможно кто-то такое уже делал?

Просто не хочется снова изобретать велосипед. Зарание спасибо.

Вот код:

//+------------------------------------------------------------------+
//|                                                      Limiter.mq4 |
//|                                      Copyright © 2008, Nazariy S.|
//+------------------------------------------------------------------+
#property copyright "Copyright © 2008, Nazariy S."
 
       double limit=8,
              st=0;
       double arr[][3];
//-------------------------------------------------------------------|
int start()
  {
   ObjectsDeleteAll();
   limit*=Point; // Переводим в пункты.
   //1--- Инициализация переменных -----------
   int      i=0,n=1;         // Счетчики.
   double   low=High[Bars-1]-limit,
            high=Low[Bars-1]+limit;
   ArrayResize(arr,Bars-1);
   //2--- Вычисление первого елемента масива --
   while(High[Bars-1-i]<high && Low[Bars-1-i]>low)
          i++;
   arr[0][1]=Time[Bars-1-i];
   if(high>=Low[Bars-1-i] && high<=High[Bars-1-i])
        {
         arr[0][0]=1;
         arr[0][2]=high;
         st=high;
        }
   else {
         arr[0][0]=0;
         arr[0][2]=low;
         st=low;
        }
   //3--- Вычисление остальных елементов -----
   for(i=Bars-1-i;i>=0;i--)
      {
       if(High[i]>=st+limit&&Low[i]<=st-limit) // Учитываем ситуацию,
       // когда одновременно High и Low достигают лимита,
        {
         if(Open[i]>=st+limit)        // тогда вычисляем по Open.
            h(i,n);
         else if(Open[i]<=st-limit)
            l(i,n);
        }
       else if(High[i]>=st+limit)
         h(i,n);
       else if(Low[i]<=st-limit)
         l(i,n);
      }
   int len=ArrayResize(arr,n)/ArrayRange(arr,1); // "Обрезаем" масив от
                                                 // лишних елементов.
   //4--- Рисуем обьекты, чтобы увидеть как всё работает.
   for(i=0;i<len-1;i++) {
       ObjectCreate(DoubleToStr(i,0),OBJ_RECTANGLE,0,
                    arr[i][1],arr[i][2],arr[i+1][1],arr[i+1][2]);
       if(arr[i+1][2]>arr[i][2])
          ObjectSet(DoubleToStr(i,0),OBJPROP_COLOR,Red);
       else if(arr[i+1][2]<arr[i][2])
          ObjectSet(DoubleToStr(i,0),OBJPROP_COLOR,Blue);
      }
   return(0);
  }
//-------------------------------------------------------------------|
void h(int i, int &n)
  {
   while(High[i]>=st+limit) {
     st+=limit;
     arr[n][0]=1;
     arr[n][1]=Time[i];
     arr[n][2]=st;
     n++;
    }
  }
//-------------------------------------------------------------------|
void l(int i, int &n)
  {
   while(Low[i]<=st-limit) {
     st-=limit;
     arr[n][0]=0;
     arr[n][1]=Time[i];
     arr[n][2]=st;
     n++;
    }
  }
//-------------------------------------------------------------------+

Вот скриншот:


Limiter, M1

 
Вы попробуйте сравнивать в условиях целые числа.
 
Zhunko писал (а) >>
Вы попробуйте сравнивать в условиях целые числа.

Извините, но не очень понял о чем вы. Мне ведь нужно сравнивать с High или Low, про какие целые числа вы имеете ввиду?

 

Используйте в условии функцию NormalizeDouble...

if(High[i]>=NormalizeDouble(st+limit,Digits)&&Low[i]<=NormalizeDouble(st-limit,Digits))
 
kharko писал (а) >>

Используйте в условии функцию NormalizeDouble...

Это тоже работать не будет.

Надо не нормализовывать путём округления (точность теряется), а умножать на 10^X, где "Х" будет требуемая точность в знаках после запятой.

Делать это надо с обоих сторон.

if (10000 * High[i] >= 10000 * (st + limit) && 10000 * Low[i] <= 10000 * (st - limit)) {}

Или так:

if (High[i] * MathPow (10, Digits) >= (st + limit) * MathPow (10, Digits) && Low[i] * MathPow (10, Digits) <= (st - limit) * MathPow (10, Digits)) {}
 
Zhunko писал (а) >>

Попробовал, но к сожелению не помогло решить проблему. Не могу понять почему нельзя использовать простое сравнение, а приходится

придумывать всякие умножение и т.п. Кстати нормализация тоже не помогла, но таких ситуаций стало минимум.

 
WWer писал (а) >>

Попробовал, но к сожелению не помогло решить проблему. Не могу понять почему нельзя использовать простое сравнение, а приходится

придумывать всякие умножение и т.п. Кстати нормализация тоже не помогла, но таких ситуаций стало минимум.

Понять нельзя, надо запомнить) Посмотрите например это 'Сравнение вещественных чисел' или 'И снова о сравнении двух double'

Новый комментарий
Причина обращения: