You are missing trading opportunities:
- Free trading apps
- Over 8,000 signals for copying
- Economic news for exploring financial markets
Registration
Log in
You agree to website policy and terms of use
If you do not have an account, please register
Talking about intuition. I want to give you an interesting example. My post, printed in this thread https://www.mql5.com/ru/forum/95632/page12more than two years ago:
1. The concept of a graphics engine.
2. Concept of the graphics core.
3. stages of creating the visual studio for the MT platform.
4. Description of the EA interface creation mechanism.
Thegraphical engine is a program designed as an indicator. This program is designed solely for management of the user interface. It executes a set of basic functions:
Graphical engine is added to a chart like any other indicator . It includes the following set of windows:
This, in principle, is the end of the graphical engine concept. The important thing is that without it the interface operation is impossible.
A graphical engine is a block of information containing data of all objects and windows in an interface, which is recorded in an array and saved in a file.
This block is a digital representation of the graphical interface. It is loaded by the graphics engine at the request of the user. The graphics engine itself has its own, internal graphics kernel which ensures operation of its own windows, and free space is provided inside this kernel for integration of the user interface (in the digital form) into it. Integration is performed in the process of loading the graphical core from a file.
3. Creating a visual studio on the MT platform, as I understand it, is divided into two stages:
4. I would like to outline the mechanism of interface creation process and slightly lift the veil on its technology. Explain where the ease of creating an interface via a file comes from.
This is the case: the engine has a special function which creates a complete graphical kernel based on a single file with a minimum amount of loading information. Boot information in this file is self-explanatory and human-readable. It is easy to write and edit. For example you need to write "_CREATE_NEW_WINDOW" to create a window, and "_CHECKBOX" and name of checkbox, (engine automatically recognizes name of element, as name of element itself and as name of its parameter).
This function is called "G_CORE_BUILDER()" and it builds the graphical core by taking data from two main sources: a boot-up file created by the user and "CONTENT[]" array containing all standard groups of objects included in windows and controls platforms. " CONTENT[]" also contains states and scripts of objects. Everything in one array. In general, the source material from "CONTENT[]" + the loader file created by the user is used by "G_CORE_BUILDER()" to build the graphical core with which the engine works.
It's amazing how much the terms and concepts have NOT changed in two years of hard work. And functions and arrays and keywords are as it says here. Everything has been implemented according to this scenario. And this technology is working and evolving, despite thefact that two years ago, I had NO experience in developing a markup language at all.
I didn't reach a dead end, I didn't change the concept, I didn't change the direction. I continued to create the engine, the core and the markup language exactly as I originally intended. And practice confirms that the path I chose was the right one.
If this is not prophetic intuition, then what is?
Dear opponents.
Here is the script code which:
Result:
My solution is more than 10 times faster.
Add to your solution, the time to save the resource and the time to get the resource into the array using ResourceReadImage();
In my solution, neither the first nor the second is required.
My solution is more than 10 times faster.
Peter, if you work with string, you will lose performance in any case. So it's surprising to hear you chasing a mythical performance, even though you originally chose an unsuitable solution for it: passing messages through a string and then parsing that message.
Peter, if you work with string, you will lose performance in any case. So it's surprising to hear you chasing mythical performance, even though you originally chose an unsuitable solution for it: passing messages through a string and then parsing that message.
Vasily, how else do you transfer data of all types between programs?
OnChartEvent() is partially suitable.
And by the way, measuring less than 20 milliseconds, strictly speaking is not valid at all, at least in systems with preemptive multithreading. But even if you accept your result (in general I admit it), it still doesn't tell you anything, because it's the full-circle costs that matter. And what you have measured is only part of it.
We need a universal and the fastest way. To work in the tester and to bypass the OnChartEvent() event queue;
The test shows that it's 10 times slower to transfer through the resources. (without measuring time for saving resource and getting data from itusing ResourceReadImage()) .
My solution is the best option under initial conditions.
...But even if you accept your result (in general I admit it), it still doesn't tell you anything, because it's the full-circle costs that matter. And what you have measured is only part of it.
True, but if you extrapolate to more lines and gears, my option still wins.
Vasiliy, how else do you transfer data of all types between programs?
Direct mapping of structures via union to byte array, shared for global access. I don't know if this is technically feasible, but if so, the speed will be cosmic, because you won't have to copy anything at all.