Alternative Implementierungen von Standardfunktionen/-ansätzen - Seite 12

 
Nikolai Semko:

Wow - cool! Danke. Und ich dachte: Das zählt jedes Mal. Ja, das ist logisch, das kann man schon bei der Kompilierung berechnen.
Also, etwa so:

Es wäre jedoch korrekter,DBL_MANT_DIG anstelle von 53 zu schreiben.

Fall des minimalen Gewinns, wenn alle Werte von double gebrochen sind.

1. Ihre Implementierung ist unvollständig, sie kann nur verwendet werden, wenn der Bereich der möglichen Werte im Voraus bekannt ist.

Hier ist der Code der vollständigen Implementierung

union Double
  {    
   double x;
   ulong  ul;
  };

double Ceil (double x)
  {
   Double dbl;   
   dbl.x=x;   
//--- убираем знак
   ulong uv=dbl.ul & 0x7fffffffffffffff;
//--- значение меньше единицы
   if(uv<0x3FF0000000000000)
     {
      //--- ноль возвращаем как есть
      if(!uv)
         return(x);
      //--- оставим только знак
      dbl.ul &= 0x8000000000000000;
      //--- положительные округляем до 1.0
      if(!dbl.ul)
         return(1.0);
      //--- отрицательные округляем до -0.0
      return(dbl.x);
     }
//--- полностью целое число
   if(uv>=0x4340000000000000)
      return(x);
//--- получим знак
   ulong sign=dbl.ul&0x8000000000000000;     
//--- IEEE магия (для домашнего изучения)
   ulong nuv=uv & ~(((ulong)1<<(51-char(uv>>52)))-1);
//--- для положительного значения
   if(!sign)
     {          
      dbl.ul=nuv;
      //--- добавим единицу, если число не целое
      if(nuv!=uv)      
         dbl.x+=1.0;
     }
   else
     {
      //--- для отрицательного просто добавим знак
      dbl.ul=nuv|sign;
     }
//---   
   return(dbl.x);
  }
2018.08.27 16:11:15.014    TestRound (EURUSD,H1)    Время выполнения ceil =  6.382 наносекунд, Контрольная сумма = 507104
2018.08.27 16:11:15.028    TestRound (EURUSD,H1)    Время выполнения Ceil =  4.792 наносекунд, Контрольная сумма = 507104


2. Selbst geschriebene Funktionen sind deutlich langsamer als eingebaute Funktionen, wenn sie zum Debuggen kompiliert werden und die Optimierungen deaktiviert sind.

 
Ilyas:

1. Ihre Implementierung ist unvollständig und kann nur verwendet werden, wenn der Bereich der möglichen Werte im Voraus bekannt ist.

Hier ist der Code für die vollständige Implementierung

2. Selbst geschriebene Funktionen sind viel langsamer als eingebaute Funktionen, wenn sie für das Debugging kompiliert werden und die Optimierungen deaktiviert sind.

Vielen Dank, Ilyas, für den hervorragenden Code.

Natürlich ist es hier ein großer Helfer.

Ich studiere sie.

Ist das nicht das Gleiche?
 
Nikolai Semko:


Nikolai, hallo. Ich sehe, dass Sie an Grafiken arbeiten, aber ich verstehe nicht ganz, was die eigentliche Aufgabe ist. Woran arbeiten Sie gerade?

Beschleunigung der Rendering-Funktionen?

 
Ich wollte über das Thema spekulieren: Man kann Russland nicht mit dem Verstand verstehen, aber dann habe ich mich dem Thema zugewandt: alternative Implementierungen von Standardfunktionen/-ansätzen.
 

Generell zum Thema des Threads: Ich habe es geschafft, einen völlig anderen Ansatz für das Zeichnen auf Leinwand zu implementieren. Ohne Verwendung der CCanvas-Klasse.

Das heißt, es geht nicht darum, einen separaten Satz von Funktionen zu ändern, sondern einen kompletten Zeichenmechanismus zu schaffen, der aus einem einzigen Block besteht.

(Natürlich kann ich das alles kaum im Code demonstrieren, da es eine Menge Code gibt und er nicht standardmäßig geschrieben ist, aber ich möchte es Ihnen allgemein sagen).

Also:

1. der Block (Funktion)

void Нарисовать_элемент(int Канвас, int Элемент = 0) 

akzeptiert nur 2 Parameter - Kanvas und Element.

  • Kanvas ist ein MT-Objekt,
  • Element ist eine Zeichnung.

2. Jedem MT-Objekt wird eine eigene Ressource zugewiesen. Es wird sofort mit ResourceReadImage() in das "Pixel-Array" geladen; wenn die Ressource noch nicht existiert, wird ein Flag gesetzt, das anschließend den Bereich des Zyklus über den Kernel bestimmt.

3. Kernel, der ein Array von Eigenschaften aller Elemente ist. Sie enthält Daten über die Größe der Objekte und die Farben der verschiedenen Zustände. Und eine Menge anderer Daten. Für jedes Objekt gibt es insgesamt 235 Eigenschaften. Gleichzeitig kann jedes Element (je nach Typ) zwischen einem und 11 Objekten enthalten (es gibt keine Begrenzung).

4. Im Zeichnungsblock stellt jedes Objekt ein "Detail" der Zeichnung dar. Der Zyklus nach Objekt im Kernel ist also ein Zeichnungszyklus, in dem das Bild jedes Details erstellt wird. Wenn ein Canvas noch nicht erstellt wurde, wird ein vollständiger Zyklus nur für alle Details dieses Canvas durchgeführt. Die Zugehörigkeit zu den Kanvas ist im Kern vorgeschrieben, für jedes Detail. Das heißt, alle Kanvases (und Teile) haben ihre eigenen Sequenznummern. Durch diese Zahlen ist es möglich, den Inhalt nur der erforderlichen Kanvas zu zeichnen.

4. Wenn ein Kanvas bereits existiert und sein Bild in einem Array von Pixeln geladen ist und wir nur ein einziges Element neu zeichnen müssen (z. B. bei einem Farbwechselereignis), dann wird der Bereich der Kernschleife auf die Grenzen des einzelnen Elements eingegrenzt, dessen Nummer von der Zeichenfunktion ermittelt wurde.


Die Zeichnung selbst ist einfach. Es handelt sich um einen Zyklus durch die Zellen eines eindimensionalen Feldes von links nach rechts. Bevor der Zyklus eingestellt wird:

1. Die Ausgangszelle (Punkt A).

2. Die Endzelle (Punkt B).

3. Treten Sie vor.

Es ist schwer, die Funktionsweise eines Blocks von 1500 Codezeilen in einer Nussschale zusammenzufassen. Es handelt sich um eine Funktion, die seit 20 Monaten wächst und sich weiterentwickelt. Ich kenne sie fast auswendig, was es mir leicht macht, sie weiterzuentwickeln.

Durch die Verwendung des Kerns und des Fokus (indem wichtige Variablen in den globalen Bereich gesetzt werden) erhält der Block enorme Möglichkeiten. Ihre Grenzen sind für mich bis heute nicht erkennbar.

Das ist die Alternative zur Standard-Kanvas-Zeichnung.


zy. Wenn Sie an den Einzelheiten interessiert sind, kann ich Ihnen das erklären.

 

So sieht der Anfang des Blocks aus:

 //+------------------------------------------------------------------+
//|                                                     Анимация.mqh |
//|                                                      Peter Konow |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Peter Konow"
//--------------------------------------------------------------------
#include<CONNECTION.mqh>
//--------------------------------------------------------------------

//--------------------------------------------------
void Нарисовать_элемент( int Канвас, int Элемент = 0 )
{
 int _Цвет_,_Поправка, Указание = Элемент; 
   int        Цвет_текста,Размер_шрифта,Стиль_шрифта, Длинна_этого_текста, X_Координата_текста,Отступ_X,Отступ_Y;
   string     Текст, Шрифт; 
 //----------------------------------------
 //----------------------------------------  
 int Эта_деталь,Номер_пикселя_элемента,Угол_наклона_детали, Цвет_детали,Ячейка_состояния,Последняя_деталь, 
     Индекс_лейбла,Исходный_элемент,Этот_X,Этот_Y,Низ,Право,Цвет_пикселя,Alfa,Массив_пикселей[],
     Метод_расчета_цвета,Градиент_поверхности,Всех_полос_градиента,Шаг_градиента,Градиент_этого_состояния,Шаг_градиента_этого_состояния;
 //----------------------------------------
 int Окно = G_CORE[Канвас][_W_NUMBER];
 int MAIN_FRAME          =   Окно + 1 ; 
 int Последний_объект    = G_CORE[Окно][_LAST_OBJECT];
 //----------------------------------------
   if (Элемент != REDROW_WHOLE_CANVAS && Элемент != REDROW_CHANGED_ELEMENTS)Исходный_элемент = Элемент;
   else 
    {
     Исходный_элемент = G_CORE[Окно][_FIRST_OBJECT];
    }    
 //-----------------------------------------------------------------
 int X_Исходного_элемента       =  G_CORE[Исходный_элемент][_X]; 
 int Y_Исходного_элемента       =  G_CORE[Исходный_элемент][_Y]; 
 int X_SIZE_исходного_элемента  =  G_CORE[Исходный_элемент][_X_SIZE]; 
 int Y_SIZE_исходного_элемента  =  G_CORE[Исходный_элемент][_Y_SIZE]; 
 int Низ_исходного_элемента     =  Y_Исходного_элемента + Y_SIZE_исходного_элемента;
 int Право_исходного_элемента   =  X_Исходного_элемента + X_SIZE_исходного_элемента;
 //----------------------------------------------------------------
   int hight, width, Ресурс_существует;
   int GAC, Событие_изменения_GAC; 
   //-----------------------------------
  GAC                     = G_CORE[Канвас][_GLOBAL_ALFA_CORRECTION];
  Событие_изменения_GAC   = G_CORE[Канвас][_GLOBAL_ALFA_CHANGED];
   //-----------------------------------
 //-------------------------------------------------- 
 //Определяем метод расчета цвета. Если глобальная Alfa != 0,
 //то расчитываем по методу COLOR_FORMAT_ARGB_NORMALIZE (медленный метод),
 //если глобальная Alfa == 0, то расчитываем по методу COLOR_FORMAT_ARGB_RAW.
 //----- || G_CORE[Канвас][_CUSTOM_BACKGROUND_TRANSPERANCY]---------------------------------------------
 if (GAC)Метод_расчета_цвета = COLOR_FORMAT_ARGB_NORMALIZE ;
 else    Метод_расчета_цвета = COLOR_FORMAT_ARGB_RAW ;
 //Alert("*",__FUNCTION__,"*"," Метод_расчета_цвета  ",Метод_расчета_цвета);
 //--------------------------------------------------     
  
  Имя_ресурса = "::" + ( string )G_CORE[Канвас][_NAME];
  Ресурс_существует = ResourceReadImage (Имя_ресурса,Массив_пикселей,width,hight);
   //-----------------------------------
  Последняя_деталь = G_CORE[Окно][_LAST_OBJECT];
   //-----------------------------------
   if (Ресурс_существует)
    {
     if (!Элемент)Элемент = ЭЛЕМЕНТ;
     Эта_деталь = Элемент; 
    } 
 //------------------------------------  
   if (
        ( Ресурс_существует 
     && (
            Событие_изменения_GAC 
         || Событие_развертки 
         || Переименование_файла 
         || Переименование_папки 
         || Изменение_ширины_столбца
         || Явление_столбцов
         || Ротация_колонок
         || (Элемент == REDROW_WHOLE_CANVAS)
        ))
      || !Ресурс_существует  
      ||  !G_CORE[Окно][_WINDOW_WAS_OPENED]
      ||  !G_CORE[Канвас][_RESOURCE_CREATED]
    )
    {
     if (Ресурс_существует)Ресурс_существует = 0 ;
     ArrayResize (Массив_пикселей,G_CORE[Канвас][_Y_SIZE] * G_CORE[Канвас][_X_SIZE]);
     Эта_деталь = MAIN_FRAME; //Канвас - 1; 
     //-----------------------------   
     if (Событие_изменения_GAC)G_CORE[Канвас][_GLOBAL_ALFA_CHANGED] = 0 ;     
    }
 //-------------------------------------
 if (Событие_динамичного_окна)
   {
    Эта_деталь = Канвас;
    Последняя_деталь = Канвас  + 18 ;
   } 
 //-------------------------------------
 if (Указание == REDROW_CHANGED_ELEMENTS)
   {
    Эта_деталь       = 6561 ; //Канвас;
    Последняя_деталь = obj_limit; //G_CORE[G_CORE[Канвас][_W_NUMBER]][_LAST_OBJECT];////
   } 
 //-------------------------------------
 //-------------------------------------
//==================================================================================================================================================================================================== 
//==================================================================================================================================================================================================== 
//==================================================================================================================================================================================================== 
//==================================================================================================================================================================================================== 
//==================================================================================================================================================================================================== 
 for ( int Деталь = Эта_деталь; Деталь <= Последняя_деталь; Деталь++)
   {
     if (!G_CORE[Деталь][_NAME]){ break ;} 
     //-------------------------------------------------------------
     //На событиях интерактивности, если ресурс канваса уже был создан, мы меняем только
     //одну деталь на этом канвасе и выходим из цикла.
     //-------------------------------------------------------------
     int     _Элемент                    =   G_CORE[Деталь][_MAIN]; 
     int     Головной_элемент_группы     =   G_CORE[_Элемент][_GROUP_HEAD_OBJECT];
     string Его_имя                     =   CONTENT[G_CORE[_Элемент][_N_TEXT]];
     int     Деталь_спрятана             =   G_CORE[Деталь][_HIDE];
     //-------------------------------------------------------------
     int Поставлен_в_очередь_на_перерисовку = G_CORE[_Элемент][_REDROW];
     //-------------------------------------------------------------
     int     Элемент_синхронизирован     =   G_CORE[_Элемент][_SYNC];
     int     Канвас_детали               =   G_CORE[Деталь][_CANVAS];
     int     Категория_канваса           =   G_CORE[Канвас_детали][_CATEGORY];
     int     Тип_объекта_детали          =   G_CORE[Деталь][_OBJ_TYPE];
     int     Группа_элемента_детали      =   G_CORE[_Элемент][_GROUP]; 
     int     Элемент_таблицы             =   G_CORE[_Элемент][_TABLE];    
   // if(Событие_динамичного_окна)Alert("Канвас  ",Канвас,"  Эта_деталь  ",Эта_деталь,"  Деталь   ",Деталь,"   Канвас_детали  ",Канвас_детали); //&& Группа_элемента_детали != FIELD
     //--------------------------------------
     int     X_Элемента_этой_детали      =   G_CORE[_Элемент][_X]; 
     int     Y_Элемента_этой_детали      =   G_CORE[_Элемент][_Y]; 
     int     X_SIZE_Элемента_этой_детали =   G_CORE[_Элемент][_X_SIZE]; 
     int     Y_SIZE_Элемента_этой_детали =   G_CORE[_Элемент][_Y_SIZE]; 
     int     Низ_этого_элемента          =   Y_Элемента_этой_детали +  Y_SIZE_Элемента_этой_детали; 
     int     Право_этого_элемента        =   X_Элемента_этой_детали +  X_SIZE_Элемента_этой_детали;     
     //--------------------------------------
     int Деталь_спрятана_функцией       =   G_CORE[Деталь][_HIDDEN_BY_FUNCTION]; 
     int Эта_деталь_спрятана                =   G_CORE[Деталь][_IS_HIDDEN];
     int Элемент_спрятан                    =   G_CORE[_Элемент][_IS_HIDDEN];
     int Элемент_спрятан_функцией       =   G_CORE[_Элемент][_HIDDEN_BY_FUNCTION]; 
     int Головной_элемент_группы_спрятан_функцией = G_CORE[Головной_элемент_группы][_HIDDEN_BY_FUNCTION];   
     //-------------------------------------- 
     int Контроллер_явления             =   G_CORE[_Элемент][_APPEARANCE_ID]; 
     int Управляемость_явлением         =   Контроллер_явления;
     //--------------------------------------
     if (Управляемость_явлением)
      {
       int Состояние_контролирующего_элемента = G_CORE[Контроллер_явления][_CURRENT_STATE];
      } 
     //--------------------------------------          
     int     X_этой_детали               =   G_CORE[Деталь][_X]; 
     int     Y_этой_детали               =   G_CORE[Деталь][_Y]; 
     int     X_SIZE_этой_детали          =   G_CORE[Деталь][_X_SIZE]; 
     int     Y_SIZE_этой_детали          =   G_CORE[Деталь][_Y_SIZE]; 
     int     Низ_этой_детали             =   Y_этой_детали +  Y_SIZE_этой_детали; 
     int     Право_этой_детали           =   X_этой_детали +  X_SIZE_этой_детали; 
     //-------------------------------------------------------------
     int   Элемент_под_курсором          =   G_CORE[_Элемент][_ELEMENT_POINTED];     
     //-------------------------------------------------------------
     if (Группа_элемента_детали != I)
      {
       Этот_X = X_Элемента_этой_детали;
       Этот_Y = Y_Элемента_этой_детали;
       Низ    = Низ_этого_элемента;
       Право  = Право_этого_элемента;
      }
     else
      {
       Этот_X = X_этой_детали;
       Этот_Y = Y_этой_детали;
       Низ    = Низ_этой_детали;
       Право  = Право_этой_детали;
      }  
     //-------------------------------------------------------------
       int     Тип_привязки_детали_по_оси_X        =   G_CORE[Деталь][_A1]; 
       int     Позиция_текста_на_элемента          =   G_CORE[Деталь][_TEXT_POSITION];                      
       int     Тип_детали                          =   G_CORE[Деталь][_BITMAP_TYPE];
       int     Категория_детали                    =   G_CORE[Деталь][_CATEGORY];
       int     Подкатегория_детали                 =   G_CORE[Деталь][_SUBCATEGORY];
       int     Номер_состовного_элемента           =   G_CORE[Деталь][_SUB_ELEMENT];
     //-------------------------------------------------------------    
     if (
            (
                !Деталь_спрятана_функцией 
             && !Элемент_спрятан_функцией 
             && !Головной_элемент_группы_спрятан_функцией 
             && !Эта_деталь_спрятана
             && !Элемент_спрятан
            )
        && !(Управляемость_явлением && Состояние_контролирующего_элемента != _ACTIVATED_STATE && Состояние_контролирующего_элемента != _ACTIVATED_HIGHLIGHTED && Состояние_контролирующего_элемента != _ACTIVATED_BLOCKED)
        &&((
               Ресурс_существует 
           && (   //рисуем детали только этого элемента
                  _Элемент == Элемент
                   //Рисуем все детали канваса на событии изменения ширины столбца таблицы. 
               || Изменение_ширины_столбца
               || Явление_столбцов
               || Ротация_колонок
               //Этот элемент синхронизирован с исходным элементом.
               // || Элемент_синхронизирован == Исходный_элемент
                   //или элементов которые находятся на площади этого элемента и должны быть перерисованы, чтобы не быть загороженными.
              || ( 
                      ((Этот_X <= X_Исходного_элемента && Право_этого_элемента > X_Исходного_элемента
                    &&  Этот_Y <= Низ_исходного_элемента && Низ_этого_элемента >= Y_Исходного_элемента)  
                                        
                    ||(Этот_X >= X_Исходного_элемента && Этот_X <= Право_исходного_элемента
                    && Этот_Y >= Y_Исходного_элемента && Этот_Y <= Низ_исходного_элемента))
                    && !Элемент_таблицы     
                  ) 
               || (G_CORE[_Элемент][_REDROW] && ((Событие_открытия_окна && !Событие_обновления_окна) || (Указание == REDROW_CHANGED_ELEMENTS && Канвас_детали == Канвас)))   
              ) //только  этого канваса и только НЕ сам канвас как деталь.  && Группа_детали_исходного_элемента != TEXT
           && (Канвас_детали == Канвас && ((Деталь != Канвас || (Событие_динамичного_окна && Деталь != Канвас + 2 )) || Перерисовка_окна_в_фокусе))
          )
       //Если ресурс не существует, то рисуем все детали этого канваса.   
       || (!Ресурс_существует && Канвас_детали == Канвас)) 
      )    
     { //if(!Ресурс_существует && Канвас_детали == Канвас)if(Событие_Drag_n_Drop)
       //Alert("*",__FUNCTION__,"*","  Имя элемента  ",Его_имя,"  Эта_деталь  ",Деталь,"    Деталь_спрятана  ",Деталь_спрятана,"  X_Элемента_этой_детали  ",X_Элемента_этой_детали,"  Y_Элемента_этой_детали  ",Y_Элемента_этой_детали);//if(СОБЫТИЕ_ИНТЕРФЕЙСА == _SCROLLER_EVENT || СОБЫТИЕ_ИНТЕРФЕЙСА == _OBJECT_POINTED)Alert("*",__FUNCTION__,"*","   Окно  ",Окно,"  Канвас  ",Канвас," _MAIN ",G_CORE[Деталь][_MAIN],"  Деталь  ",Деталь,"   Группа элемента   ",G_CORE[Деталь][_GROUP]);
       //---------------------------------------
       //if(Перерисовка_окна_в_фокусе && Категория_канваса == _OCWC)Alert(__FUNCTION__,"  Перерисовка_окна_в_фокусе, Категория_канваса == _OCWC");
       //---------------------------------------
       //Снимаем флаг очереди на перерисовку после прохождения условия.
       //---------------------------------------
       if (Поставлен_в_очередь_на_перерисовку && Деталь == _Элемент + G_CORE[_Элемент][_ALL_OBJECTS_IN_ELEMENT] - 1 )
        {
         G_CORE[_Элемент][_REDROW] = 0 ;
        } 
       //---------------------------------------
     // int Пиксель_канваса_детали      =  G_CORE[Канвас_детали][_PIXEL_INDEX];
       int Состояние_канваса_детали    =  G_CORE[Канвас_детали][_CURRENT_STATE];
       int Ячейка_состояния_канваса    =  G_CORE[Канвас_детали][_NEUTRAL_STATE];
       //-------------------------------------
     // int Цвет_пикселя_канваса_детали =  STANDART_GROUPS[Ячейка_состояния_канваса + 3 + Пиксель_канваса_детали*2];
       //---------------------------------------
       int     Состояние_элемента                  =   G_CORE[_Элемент][_CURRENT_STATE];
       //---------------------------------------
       if (!Состояние_элемента)
        {
         Состояние_элемента = _NEUTRAL_STATE;
         G_CORE[_Элемент][_CURRENT_STATE] = _NEUTRAL_STATE;
        }
       //--------------------------------------  
       int     Состояние_детали                    =   G_CORE[Деталь][_CURRENT_STATE];
       //--------------------------------------- 
       if (Состояние_детали != Состояние_элемента)
        {
         Состояние_детали = Состояние_элемента;
         G_CORE[Деталь][_CURRENT_STATE] =  Состояние_элемента;
        } 
       //Alert("Нарисовать_элемент()  _Элемент  ",_Элемент,"  Деталь  ",Деталь, "   Группа элемента   ",G_CORE[_Элемент][_GROUP]," Cостояние элемента  ",G_CORE[_Элемент][_CURRENT_STATE]," Состояние_детали  ",G_CORE[Деталь][_CURRENT_STATE]);   
       //---------------------------------------
       int     Состояние_составного_элемента       =   G_CORE[Номер_состовного_элемента][_SUB_ELEMENT_CURRENT_STATE];
       //---------------------------------------
       //Условие if(!Состояние_составного_элемента) создавало баг - было переопределение состояния главого элемента детали.
       //---------------------------------------
       if (!Состояние_составного_элемента && Номер_состовного_элемента != _Элемент)
        {
         Состояние_составного_элемента  =   _NEUTRAL_STATE;
         G_CORE[Номер_состовного_элемента][_CURRENT_STATE] = _NEUTRAL_STATE;
        }  
       //---------------------------------------  
       //Определяем текущее состояние детали по состоянию составного элемента, которому она принадлежит. 
       //(При этом, составной элемент может быть главным элементом).
       //---------------------------------------    
       if (G_CORE[Деталь][_SUB_ELEMENT] == _Элемент)
        {
         Состояние_детали = Состояние_элемента;
         // Alert("_SUB_ELEMENT   ",G_CORE[Деталь][_SUB_ELEMENT],"   Состояние_элемента   ",Состояние_элемента,"  Состояние_составного_элемента  ",Состояние_составного_элемента,"  Состояние_детали ",Состояние_детали); 
        } 
       //---------------------------------------
       //При этом, если деталь принадлежит составному элементу, то ее состояние совпадаем с состоянием составного элемента,
       //которое прописано в другом параметре, - не _CURRENT_STATE, а _SUB_ELEMENT_CURRENT_STATE. Это значит,
       //что если деталь принадлежит главному элемету, ее состояние будет братся из параметра _CURRENT_STATE главного элемета,
       //а если принадлежит составному, - то из параметра _SUB_ELEMENT_CURRENT_STATE составного элемета.
       //Поэтому добавлено условие: " && Номер_состовного_элемента != _Элемент".
       //---------------------------------------
       if (G_CORE[Деталь][_SUB_ELEMENT] == Номер_состовного_элемента && Номер_состовного_элемента != _Элемент)
        {
         Состояние_детали = Состояние_составного_элемента;
        } 
       //---------------------------------------
   
       //---------------------------------------
       int Группа_составного_элемента             =   G_CORE[Номер_состовного_элемента][_SUB_ELEMENT_GROUP];
       //---------------------------------------
       int Высота_элемента                        =   G_CORE[_Элемент][_Y_SIZE];  
       int Ширина_элемента                        =   G_CORE[_Элемент][_X_SIZE];     
       //--------------------------------------- 
       int X_детали                               =   G_CORE[Деталь][_X];
       int Y_детали                               =   G_CORE[Деталь][_Y];
       //-----------------------
       if (!G_CORE[Деталь][_SUB_ELEMENT_CURRENT_STATE])G_CORE[Деталь][_SUB_ELEMENT_CURRENT_STATE] = _NEUTRAL_STATE;
       //-----------------------
       int Объект_A2G                             =   G_CORE[Деталь][_ADAPT_2_GRADIENT];
       //--------------------------------
       int Тип_сценария                           =   G_CORE[Деталь][_CURRENT_SCENARIO_TYPE];
       int Номер_сценария                         =   SI_PROPERTIES[G_CORE[Деталь][_SI_PROPERTIES]][Тип_сценария];  
       int Эта_сцена                              =   G_CORE[Деталь][_CURRENT_SCENE]; 
       int Значение_по_сценарию                   =   SCENARIOS[Номер_сценария][Эта_сцена];         
       //--------------------------------
       int X_полотна                              =   G_CORE[Канвас][_X];
       int Y_полотна                              =   G_CORE[Канвас][_Y]; 
       //--------------------------------
       //--------------------------------
       int Отступ_детали_X                        =   X_детали - G_CORE[Канвас][_X];
       int Отступ_детали_Y                        =   Y_детали - G_CORE[Канвас][_Y];
       //--------------------------------
       int Высота_детали                          =   G_CORE[Деталь][_Y_SIZE];
       int Длинна_детали                          =   G_CORE[Деталь][_X_SIZE];
       //-----------------------
       int Ширина_полотна                         =   G_CORE[Канвас][_X_SIZE];
       int Высота_полотна                         =   G_CORE[Канвас][_Y_SIZE]; 
       //-----------------------
       int Правая_граница_детали                  =   X_детали  + Длинна_детали;
       int Правая_граница_полотна                 =   X_полотна + G_CORE[Канвас][_X_SIZE];      
       //-----------------------
      _Поправка = 0 ;
       //-----------------------
       if (Подкатегория_детали == _DINAMIC_PLATFORM)
        {
         _Поправка = 30 ;
         Длинна_детали                           =   G_CORE[Канвас][_VISIBLE_X_SIZE] + _Поправка;
         Высота_детали                           =   G_CORE[Канвас][_VISIBLE_Y_SIZE] + _Поправка;
         Правая_граница_детали                   =   X_детали  + Длинна_детали;
         Правая_граница_полотна                  =   X_полотна + Длинна_детали;    
         //-------------------------------------
       
        }    
       //--------------------------------
 
Ilyas:

1. Ihre Implementierung ist unvollständig und kann nur verwendet werden, wenn der Bereich der möglichen Werte im Voraus bekannt ist.

Hier ist der Code für die vollständige Implementierung

Nochmals vielen Dank für den Code. Ich habe über diese Bit-Masken gerätselt wie über eine doppelte. Es stellt sich heraus, dass es nicht so einfach ist, wie ich vorher dachte.
Ich habe meine Version leicht an Ihre angepasst. Es gab nur einen Unterschied: Ihre Version ergab bei den Werten -1>x>0 Ceil(-0.1)= - 0.0, während meine Version 0.0 ergab. Ich weiß allerdings nicht, wann das nützlich sein könnte.

Und Sie erhalten Folgendes:

//double Ceil(double x) { return double((x!=x || x>(long)1<<53 || x<-(long)1<<53)?x:(x-(long)x>0)?(long)x+1:(long)x);}
  double Ceil(double x) { return double((x!=x || x>(long)1<<53 || x<-(long)1<<53)?x:(x-(long)x>0)?(long)x+1:(x>-1 && x<0)?-0.0:(long)x);}

Das Gleiche, nur lesbar und mit Kommentaren:

double Ceil(double x)
  {
   if(x!=x ||            // если x = NaN(SNaN) т.е. переполнение или ошибка
      x> (long)1<<53 ||  // или число x положительное и превышает максимальную возможную мантиссу, т.е. дробная часть в x точно отсутствует 
      x<-(long)1<<53)    // или число x отрицательное и превышает максимальную возможную мантиссу, т.е. дробная часть в x точно отсутствует 
      return(x);
   if(x-(long)x>0)       // Если число положительное или дробная часть не равна нулю
      return(long)x+1.0; // добавляем к бездробной части 1
   else if(x>-1 && x<0)  // Если -1 < x < 0
   return -0.0;          // то возвращаем -0.0
   else return (double)long(x);
  }

Ich habe ein Skript geschrieben (im Anhang), das die 100%ige Identität mit Ihrer Version bestätigt.
Aber diese Variante ist schneller, kompakter und meiner Meinung nach auch besser lesbar.

Beachten Sie, dass im Funktionsrumpf keine einzige Variable erzeugt wird, während Ihre Version 4 8-Byte-Variablen erzeugt.
Vielleicht liege ich falsch?

Ergibt sich, wenn die Eingabe x immer einen gebrochenen Teil hat:

2018.08.27 18:42:37.616 TestCeil (EURUSD,M1)    Время выполнения функции CeilI =  1.321 наносекунд, Контрольная сумма = 5250492895.0
2018.08.27 18:42:37.619 TestCeil (EURUSD,M1)    Время выполнения функции CeilN =  1.094 наносекунд, Контрольная сумма = 5250492895.0
2018.08.27 18:42:37.623 TestCeil (EURUSD,M1)    Время выполнения функции ceil =  2.962 наносекунд, Контрольная сумма = 5250492895.0
2018.08.27 18:42:37.623 TestCeil (EURUSD,M1)    Идет бесконечный поиск расхождения по случайным числам double ... Прервите скрипт, когда надоест ждать

Ergebnisse, bei denen die Eingabe x einen gebrochenen Teil hat, sind selten:

2018.08.27 18:49:45.734 TestCeil (EURUSD,M1)    Время выполнения функции CeilI =  0.307 наносекунд, Контрольная сумма = 1.15583114403606 e+23
2018.08.27 18:49:45.736 TestCeil (EURUSD,M1)    Время выполнения функции CeilN =  0.102 наносекунд, Контрольная сумма = 1.15583114403606 e+23
2018.08.27 18:49:45.738 TestCeil (EURUSD,M1)    Время выполнения функции ceil =  1.026 наносекунд, Контрольная сумма = 1.15583114403606 e+23
2018.08.27 18:49:45.738 TestCeil (EURUSD,M1)    Идет бесконечный поиск расхождения по случайным числам double ... Прервите скрипт, когда надоест ждать
Ilyas:


2. Selbst geschriebene Funktionen sind deutlich langsamer als eingebaute Funktionen, wenn sie zum Debuggen kompiliert werden und die Optimierungen deaktiviert sind.

Es ist nicht klar, warum die Geschwindigkeit bei der Fehlersuche benötigt wird.
Aber wenn Sie es wirklich brauchen, können Sie das Konstrukt verwenden:

#ifdef _DEBUG x=Ceil(y);
#else  x=ceil(y); #endif 


Und es gibt noch etwas, das ich nicht verstehe:

Warum ist die Dokumentation und die tatsächliche DBL_MANT_DIG = 53 ?

wie laut der gleichen Wikipedia= 52.
Und aus Ihrem Code geht hervor, dass auch 52 ?

Dateien:
TestCeil.mq5  15 kb
 
Реter Konow:

Nikolai, hallo. Ich sehe, dass Sie an Grafiken arbeiten, aber ich verstehe nicht ganz, was die eigentliche Aufgabe ist. Woran arbeiten Sie gerade?

Beschleunigung der Rendering-Funktionen?

Hallo Piotr!
Ich werde persönlich antworten.

 
 
Nikolai Semko:
Und es gibt noch etwas, das ich nicht verstehe:

Warum ist die Dokumentation und die tatsächliche DBL_MANT_DIG = 53 ?

wobei laut der gleichen Wikipedia= 52.
Und es scheint, dass Ihr Code auch impliziert, dass es 52 ist?

Haben Sie selbst versucht, die Antwort auf diese Frage zu finden?

Tipp: Geben Sie in der Google-Suche "DBL_MANT_DIG 53 52" ein.