MetaTrader 5 herunterladen

Effektive Mittelwertbildungsalgorithmen mit minimalen Lags und ihre Verwendung in Indikatoren

14 April 2016, 13:27
Nikolay Kositsin
0
269

Einleitung

Ich denke, es gibt keine Notwendigkeit zu erklären, wie wichtig die Glättungsalgorithmen für die technische Analyse und für Handelssysteme sind. Es ist genug, nur mal auf einen Code eines Indikators zu gucken, um da explizite oder implizite einen Mittelwertbildungsalgorithmus zu finden. Wenn wir einen genaueren Blick auf Online-Handelsplattformen und Client-Terminals werfen, dann stellen wir fest, dass in meisten von ihnen einfache aber nicht so effektive Mittelwertbildungsalgorithmen verwendet werden, zwar sind aber viele basierend auf diesen Mittelwertbildungsalgorithmen programmiert worden.

Es sind schon momentan viel effektiver Glättungsalgorithmen entwickelt worden. Allerdings der Versuch, sie in Indikatoren anzuwenden, aufgrund erheblicher Komplexität der Algorithmen, haben ergeben, dass die Programmierer einfach keine Geduld hatten und machten höchstens ein oder zwei Indikatoren, die keineswegs immer richtig bedienten. Danach hatten sie in der Regel keine Lust mehr, in diese Richtung zu arbeiten. Der grundlegende Vorteil der einfachen Mittelwerte ist, dass sie immer verfügbar sind als einfache benutzerdefinierte Funktionen, die überall und jederzeit angewendet werden können.

Betreff des Artikels


In diesem Artikel möchte ich Händler, die MQL4 kennen, effektiver Mittelwertbildungsalgorithmen mit minimaler Verzögerung vorschlagen, die als einfache benutzerdefinierte Funktionen dargestellt werden. Die Verwendung dieser Funktionen ist nicht komplizierter als die Verwendung der technischen Indikatoren. Die Funktionen wurden schon vor langer Zeit geschrieben, und ihre Betriebsqualität wurde auch ziemlich lange geprüft. Aber es wurden bei ihrer Arbeit keine Fehler oder Probleme, oder falsche Berechnungen gefunden. So werden wir die folgenden Algorithmen berücksichtigen:

- JJMASeries () - ist der adaptive JMA Glättungsalgorithmus;
- JLiteSeries() - ist der JMA Glättungsalgorithmus ohne einen adaptiven Algorithmus;
- JurXSeries () - ist der Ultra-Linear-Glättungsalgorithmus aus dem Indikator JRSX;
- ParMASeries() - ist der Glättungsalgorithmus basierend auf parabolischer Annäherung;
- LRMASeries () - ist der Algorithmus basierend auf den linearen Regressions-Glättung;
- T3Series () - ist der Glättungsalgorithmus basierend auf den Tilson-Algorithmus.

Die Realisierung der Glättungsfunktion


Die Funktionen werden als die folgenden Dateien dargestellt: JJMASeries.mqh, JLiteSeries.mqh, JurXSeries. mqh, ParMASeries.mqh, LRMASeries.mqh, T3Series.mqh.

Die Funktionsaufrufe selbst sind absolut gleich, der einzige Unterschied ist, dass einige Funktionen keine einige externer Variablen haben. Solche Funktionen werden in der Regel für die Verarbeitung der individuellen und Indikator-Arrays gebaut, die als externer Variablen arbeiten. Meiner Meinung nach ist es nicht immer bequem, so wäre es viel besser, solche Funktionen für die Verarbeitung der normalen Variablen zu verwenden, und nicht Arrays. In diesem Fall kann man eine unbegrenzte Menge von Glättungen mit diesen Algorithmen innerhalb von einer Berechnungsloop machen! Ich denke, dass es nicht notwendig ist, den Code der Funktionen in diesem Artikel zu geben. Der Code wird nur für diejenigen interessant sein, die ähnliche Funktionen basierend auf die anderen Algorithmen erstellen will. Wir interessieren uns nur für den Algorithmus des Funktionsaufrufs im Code des Indikators, das heißt, die praktische Anwendung der Funktionen.


Funktion JJMASeries ()

Lass uns am Anfang die Funktion JJMASeries() kennenlernen:

double JJMASeries(int number, int din, int MaxBar, int limit, 
                  int Phase, int Length, double series, int bar,
                  int& reset)

Die Datei JJMASeries.mqh enthält vier Funktionen: JJMASeries(), JJMASeriesResize(), JJMASeriesAlert() и JMA_ErrDescr(). Die Datei enthält auch Variablen, die als globale erklärt sind.

Die Funktion JJMASeries() wird für die Verwendung des JMA-Algorithmus beim Schreiben aller technischen Indikatoren oder Expert Advisors vorgesehen, in dem die Berechnung für die klassischen Mittelwertbildung mit dem Algorithmus ersetzt wird. Die Funktion funktioniert nicht, wenn limit den Wert von Null nimmt! Alle Indikatoren, die ich für JJMASeries entwickelt habe, wurden diese Einschränkung berücksichtigen. Die Datei muss im Ordner MetaTrader\Experten\include\ gespeichert werden. Man muss auch beachten, dass die Funktion JJMASeries() den Nullwert im Bar zurück liefert, wenn der Wert der Variable bar mehr ist, als der Wert der Variable MaxBar! Und deshalb kann dieser Wert nicht als Nenner in einem Bruch für die Berechnungen eines Indikators sein! In den folgenden 30 Bars liefert die Funktion JJMASeries() auch Null zurück!

Diese Version der Funktion JJMASeries() unterstützt Advisors Experts, wenn sie in den Benutzerindikatoren verwendet wird, die von dem Expert Advisor aufgerufen werden. Außerdem ist diese Version der Funktion JJMASeries() unterstützt Advisors Experts, wenn sie im Code des Indikators verwendet wird, der vollständig im Experten-Code platziert ist, und haltet alle DO-Protokollen und Variablen gespeichert! Beim Schreiben der Indikatoren oder Expert Advisors mit der Funktion JJMASeries, ist es nicht empfohlen, die Variablen-Namen mit dem Anfang nJMA...oder dJMA ...zu benennen Die Funktion JJMASeries() kann im internen Code der anderen benutzerdefinierten Funktionen verwendet werden, wenn es angenommen wird, dass jeder Aufruf zu JJMASeries () bei jedem Aufruf zu einer solchen benutzerdefinierten Funktion seine eindeutige Nummer haben muss. Diese Version der Funktion JJMASeries() ist für die Verarbeitung der Variablen vorgesehen, die mit Arrays der Zeitreihenanordnungen vom aktuellen Chart verbunden sind! Wenn diese Funktion für die Verarbeitung der Variablen verwendet wird, die basierend auf Arrays der Zeitreihenanordnungen von den anderen Charts berechnet sind, wird ein Fehler in der Berechnung sein!

Eingabeparameter:
- number - die Ordnungsnummer des Funktionsaufrufs JJMASeries() im Code des Indikators (0, 1, 2, 3 u.s.w);
- din - der Parameter, der die Parameter Length und Phase auf jedem Bar ändern kann. 0 - das Verbot, die Parameter zu ändern, jeder andere Wert bedeutet, dass es möglich ist;
- MaxBar - Der Maximalwert, der die Nummer des berechneten Bars annehmen kann(bar). Normalerweise ist es Bars-1-Periode, wo "period" ist die Anzahl der Bars ist, auf den der Anfangswert series nicht berechnet wird;
- limit - Die Anzahl des noch nicht berechneten Bars sowie eine oder die Nummer des letzten noch nicht berechneten Bars. Es muss gleich mit Bars-IndicatorCounted()-1 sein;
- Length - Glättungstiefe;
- Phase - Der Parameter im Bereich zwischen -100 .. . und +100, Sie beeinflusst auf die Qualität des vorübergehenden Prozess;
- series - Der Eingabeparameter, über den die Berechnung der Funktion JJMASeries() durchgeführt wird;
- bar - Die Nummer des berechneten Bars. Dieser Parameter muss von dem DO aus dem Maximalwert auf Null geändert werden. Daraufhin muss der Maximalwert immer mit dem Wert von limit gleich sein!


Eingabeparameter:
- JMASeries() - der Wert der Funktion JMA. Bei Werten des Parameters bar mehr, als MaxBar-30 ist, liefert die Funktion JJMASeries() immer Null zurück!
- reset - Der Parameter, der über dem Link den Wert zurückliefert, der von 0 unterschiedlich ist, wenn es einen Fehler in der Funktionsberechnung gab und der liefert 0, wenn die Berechnung in Ordnung war. Dieser Parameter kann nur variabel sein, aber nicht einem Wert!


Funktionsinitialisierung
Bevor die Funktion JJMASeries() aufgerufen wird, und die Anzahl der berechneten Bars schon gleich mit 0 ist, sollten die Größen der internen Puffersvariablen der Funktion verändert werden (es wäre noch besser, das im Initialisierungsblock des benutzerdefinierten Indikators oder des Expert Advisors zu tun). Dazu ist es notwendig, die Variablen von der Funktion JJMASeries() durch die Hilfsfunktion JJMASeriesResize() mit den folgenden Parametern aufzurufen: JJMASeriesResize(number+1); es ist notwendig, den Parameter "number" (MaxJMA.number) gleich der Aufrufszahl zu JJMASeries zu machen, das heißt, um 1 größer als der Maximalwert von number zu machen. Zusammen mit der Änderungen der Puffersgröße von JJMASeries() kann man im Initialisierungsblock die Eingabewerte der Variable Length und Phase durch JJMASeriesAlert() prüfen, ob ihre Änderungsbereich entsprechend sind. Diese Variable sind auch die Eingabeparameter der Funktion JJMASeries():

JJMASeriesAlert(int Number, string name, int ExternVar)

- Number - Der Parameter, der zwei Werte annehmen kann: 0 - für die Überprüfung des Eingabeparameters ExternVar, ob er innerhalb des Änderungsbereichs des Eingabeparameters Length von JJMASeries() liegt und 1 - für die Überprüfung des Eingabeparameters ExternVar, ob er innerhalb des Änderungsbereichs des Eingabeparameters Phase von JJMASeries() liegt;
- name - Der String Name des Eingabeparamters ExternVar, um eine Warnung zu geben;

- ExternVar - Der Eingabeparameter des Indikators

Fehleranzeige

Wenn Indikatoren eingerichtet werden, können ihre Code Fehler enthalten. Um die Gründe zu erfahren, sollte man die Log-Datei betrachten. Die Funktion JJMASeries() zeichnet alle Fehler in der Log-Datei im Ordner mit dem Namen \MetaTrader\EXPERTS\LOGS\. Wenn ein MQL4-Fehler im Code der vorhergehenden Funktion auftritt, bevor die Funktion JJMASeries() aufgerufen wird, dann schreibt die Funktion den Fehlercode und den Inhalt des Fehlers in einer Log-Datei. Wenn ein MQL4-Fehler beim Aufruf der Funktion JJMASeries() im Algorithmus JJMASeries() auftritt, dann schreibt die Funktion den Fehlercode und den Inhalt des Fehlers in einer Log-Datei. Wenn die Nummer number beim Aufruf der Funktion JJMASeries() falsch eingegeben wird oder die Größe der Puffervariablen von nJJMAResize falsch definiert wird. In Size der Log-Datei wird die Meldung über die falsche Definition dieser Variablen geschrieben. Genauso wird die Information bei der falschen Definition des Parameters limit geschrieben.

Wenn es bei der Änderung der Puffer-Größen der Funktion JJMASeries während des Aufrufs der Funktion init() fehlschlägt, dann schreibt die Funktion JJMASeriesResize() die Information über die fehlgeschlagenen Änderung der Größen in der Log-Datei. Wenn die richtige Reihenfolge der Änderung des Parameters bar beim Aufruf der Funktion JJMASeries() durch den externen DO gestört wurde, dann wird auch diese Information in der Log-Datei geschrieben. Man muss auch beachten, dass einige Fehler des Programmcodes künftig noch andere Fehler in seiner Ausführung schaffen, und deswegen, wenn die Funktion JJMASeries() in ihrer Log-Datei direkt ein paar Fehler schreibt, dann sollen sie in der Reihenfolge ihres Auftretens beseitigt werden. In einem richtig geschriebenen Indikator kann die Funktion JJMASeries() Datensätze in der Log-Datei nur dann machen, wenn die Systemstörungen geben. Ausnahmsweise können die Größe-Änderungen der Puffer-Variablen bei der Überbelastung des Indikators oder des Expertes geschrieben werden, die bei jedem Aufruf der Funktion init() geschieht. Alle MQL4-Fehler werden in der Log-Datei mit der Funktion JMA_ErrDescr () geschrieben, die den Code und den Fehlerinhalt nach seinem Code schickt, welcher mit Hilfe von GetLastError() erhalten wird.

Das Beispiel des Aufrufs der Funktion JJMASeries() (doppelte JMA Glättung des Eingangspreises):

/*
Für  die Arbeit  des Indikators  müssen  die Daten 
JJMASeries.mqh 
PriceSeries.mqh 
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
*/
//+------------------------------------------------------------------+   
//|                                                        J2JMA.mq4 | 
//|                       JMA code: Copyright © 2005, Jurik Research | 
//|                                         http://www.jurikres.com/ | 
//|    MQL4 JJMASeries+J2JMA: Copyright © 2006,     Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+------------------------------------------------------------------+   
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im Hauptfenster
#property indicator_chart_window 
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers 1 
//---- die Farbe des Indikators
#property indicator_color1 Magenta 
//---- Eingabeparameter des Indikators 
extern int Length1 = 5; // die erste  Glättungstiefe 
extern int Length2 = 5; // die zweite  Glättungstiefe 
// Der Parameter der ersten Glättung, der sich im Bereich zwischen -100 ... +100 ändert, 
//beeinflusst auf die Qualität des vorübergehenden Prozess; 
extern int Phase1  = 100;
// Der Parameter der zweiten Glättung, der sich im Bereich zwischen -100 ... +100 ändert, 
//beeinflusst auf die Qualität des vorübergehenden Prozess; 
extern int Phase2  = 100;
// Die Verschiebung des Indikators entlang der Zeitachse 
extern int Shift   = 0;
/* Die Wahl der Preise, nach den der Indikator berechnet wird 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 
11-Heiken Ashi Low, 12-Heiken Ashi High,  13-Heiken Ashi Open, 
14-Heiken Ashi Close.) */
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double J2JMA[];
//---- die Variablen mit Gleitkomma  
double Temp_Series; 
//----+ Eingabe der Funktion JJMASeries 
//----+ Eingabe der Funktion JJMASeriesResize 
//----+ Eingabe der Funktion JJMASeriesAlert  
//----+ Eingabe der Funktion JMA_ErrDescr  
#include <JJMASeries.mqh>   
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+ 
//| J2JMA indicator initialization function                          | 
//+------------------------------------------------------------------+ 
int init() 
  {  
//---- Definieren des Zeichenstils vom Chart 
   SetIndexStyle (0, DRAW_LINE); 
//---- 1 Indikatorpuffer wurde für die Zählung verwendet 
   SetIndexBuffer(0, J2JMA);
//----  Horizontale Verschiebung der Indikator-Linie 
   SetIndexShift (0, Shift);  
//---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar werden
   SetIndexEmptyValue(0, 0); 
//---- Die Namen für Datenfenster und Labels für Unterfenster 
   IndicatorShortName ("J2JMA(Length1=" + Length1 + ", Phase1=" + Phase1 +
                       ", Length2=" + Length2 + ", Phase2=" + Phase2 + 
                       ", Shift=" + Shift + ")"); 
   SetIndexLabel (0, "J2JMA"); 
//---- Einstellung der Abbildungsgenauigkeit des Indikatorsformats 
   IndicatorDigits(Digits);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JJMASeries, 
//nJMAnumber=2(zwei Aufrufe zur Funktion JJMASeries)
   if(JJMASeriesResize(2) != 2)
       return(-1);
//---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen
   JJMASeriesAlert (0,"Length1", Length1);
   JJMASeriesAlert (0,"Length2", Length2);
   JJMASeriesAlert (1,"Phase1", Phase1 );
   JJMASeriesAlert (1,"Phase2", Phase2 );
   PriceSeriesAlert(Input_Price_Customs);
//---- Das Ende des Initialisierens 
   return(0); 
  } 
//+------------------------------------------------------------------+   
//| J2JMA iteration function                                         | 
//+------------------------------------------------------------------+ 
int start() 
  { 
//---- Die Überprüfung der Anzahl der Bars, damit sie ausreichend für die Berechnung wären
   if(Bars - 1 < 61)
       return(0);
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
   int reset, MaxBar1, MaxBar2, counted_bars = IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
   if(counted_bars < 0) 
       return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden 
//---- (Ohne diese Neuberechnung für  counted_bars wird die Funktion JJMASeries  
//     nicht korrekt funktionieren!!!)
   if(counted_bars > 0) 
       counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//     der neuen Bars beginnt
   int limit = Bars - counted_bars - 1; 
   MaxBar1 = Bars - 1; 
   MaxBar2 = MaxBar1 - 30;
 
//----+ Die Hauptloop der Berechnung des Indikators 
   for(int bar = limit; bar >= 0; bar--)
     {
       // Der Aufruf zu der Funktion PriceSeries für die Erhaltung des Eingangspreises Series
       Temp_Series = PriceSeries(Input_Price_Customs, bar);
       // zwei Aufrufe zur Funktion JJMASeries nach Nummern 0, 1. Parameter 
       //nJMA.Phase und nJMA.Length 
       //Ändern sich nicht an jedem Bar  (nJMA.din=0)
       //(Im zweiten  Aufruf des Parameters nJMA.MaxBar  wird um 30   verringert. denn es  
       //ist die wiederholte JMA Glättung)
       Temp_Series = JJMASeries(0,0,MaxBar1,limit,Phase1,Length1,
                                Temp_Series,bar,reset);
       // Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset != 0)
           return(-1);
       Temp_Series = JJMASeries(1,0,MaxBar2,limit,Phase2,Length2,
                                Temp_Series,bar,reset);
       // Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset != 0)
           return(-1);
       J2JMA[bar] = Temp_Series;
     }
//---- Das Ende der Berechnung der Indikator-Werte
   return(0); 
  } 
//+--------------------------------------------------------+


So können die folgenden Punkte in der Anwendung dieser Funktion hervorgehoben werden:
1. Erklärung der Funktionen, die im Inhalt der Datei JJMASeries. mqh mit der Zeile #include <JJMASeries.mqh> am Textanfang des Indikators sind. Es werden Variablen und vier Funktionen erklärt: JJMASeries(), JJMASeriesResize(), JJMASeriesAlert() и JMA_ErrDescr();
2. Die Änderung der Größen der Pufferelemente, die in der Funktion JJMASeries() mit der Funktion JJMASeriesResize() im Initialisierungsblock verwendet werden;
3. Die Überprüfung mit der Funktion JJMASeriesAlert() im Initialisierungsblock, ob die Werte der externen Variable vom Indikator korrekt sind, welche die externen Variable der Funktion JJMASeries() sind;
4. Die Aufrufe zur Funktion JJMASeries(), die durch den DO mit den entsprechenden Fehlerüberprüfungen gemacht wurden.


Weitere Funktionen


Der Aufruf-Algorithmus zu den anderen Funktionen mit dem oben betrachteten Algorithmus ist ähnlich, aber es gibt einige Unterschiede in der Anzahl der externen Variablen in Funktionen:
JJMASeries (int number, int din, int MaxBar, int limit, int Phase,
            int Length, double series, int bar, int&reset)
JLiteSeries(int number, int din, int MaxBar, int limit, int Phase,
            int Length, double series, int bar, int&reset)
JurXSeries (int number, int din, int MaxBar, int limit,
            int Length, double series, int bar, int&reset)
T3Series   (int number, int din, int MaxBar, int limit, int Phase,
            int Length, double series, int bar, int&reset )
ParMASeries(int number, int MaxBar, int limit, int period, 
            double series, int bar, int&reset)
LRMASeries (int number, int MaxBar, int limit, int period, 
            double series, int bar, int&reset )

Es sollte klar sein, dass die Funktionen JJMASeries() und JLiteSeries() im gleichen Expert Advisor oder Indikator nicht kompatibel sind! Tatsächlich ist in der Datei JLiteSeries. mqh der gleiche Code JMA mit dem Namen der Funktion JJMASeries() ohne Anpassung platziert worden! Um die Funktion JJMASeries() um JLiteSeries() im Experten oder im Indikator zu ersetzen, ist es genug, die Zeile #include<JJMASeries mqh> um die Zeile #include<JLiteSeries. mqh> zu ersetzen. Alle Aufrufe zu den Funktionen der Datei JLiteSeries. mqh werden als Aufrufe für die Funktionen betrachtet, die identisch zu den Funktionen der Datei JJMASeries.mqh gehen .


Weitere Funktionen sind voll kompatibel innerhalb im gleichen Indikator oder Expert Advisor-Code. In Funktionen ParMASeries () und LRMASeries (), wird der Wert der externen Variablen period mit 501 begrenzt. Wenn die größere Werte gebraucht werden, dann muss man die ersten (nicht nullwertigen) Werte der Puffers ersetzen
dParMA.TempBuffer[][501] und dParMA.TEMPBUFFER[][501] für die Funktion ParMASeries() oder dLRMA. TempBuffer[][501] und dLRMA.TEMPBUFFER[][501] für die Funktion LRMASeries() in Dateien ParMASeries. mqh und LRMASeries. mqh bzw.


Die Funktionen JurXSeries()

Das Beispiel des Aufrufs der Funktion JJMASeries() (Ultra-Linear Glättung des Eingangspreis mit zusätzlicher JMA Glättung):

/*
Für  die Arbeit  des Indikators  müssen  die Daten 
JurXSeries.mqh, 
JJMASeries.mqh, 
PriceSeries.mqh,  
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
In der Basis  auf diesen  Indikator  liegt  der Glättungsalgorithmus vom Indikator 
JRSX.    Das Endergebnis dieses Algorithmus hat einige Ähnlichkeiten mit 
der doppelten Glättung JMA, aber auf Grund ihrer Einfachheit ist weniger perfekt.
 
*/
//+------------------------------------------------------------------+
//|                                                        JJurX.mq4 | 
//|                           Copyright © 2006,     Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im Hauptfenster
#property indicator_chart_window 
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers 1 
//---- die Farbe des Indikators
#property indicator_color1 Gold
//---- Eingabeparameter des Indikators 
extern int JurX_Length  = 5; // die Glättungstiefe JurX 
extern int JJMA_Length  = 4; // die Glättungstiefe JJMA 
// Der Parameter der Glättung JJMA, der sich im Bereich zwischen -100 ... +100 ändert, 
//  beeinflusst auf die Qualität des vorübergehenden Prozess; 
extern int JJMA_Phase   = -100;
extern int Shift        = 0;      // Die Verschiebung des Indikators entlang der Zeitachse 
/* Die Wahl der Preise, nach den der Indikator berechnet wird 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 
11-Heiken Ashi Low, 12-Heiken Ashi High,  13-Heiken Ashi Open, 
14-Heiken Ashi Close.) */
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double Ind_Buffer[];
//---- die Variablen mit Gleitkomma  
double Price,JurX,JJurX,Error;
//+------------------------------------------------------------------+
//----+ Eingabe der Funktion JJMASeries 
//----+ Eingabe der Funktion JJMASeriesResize 
//----+ Eingabe der Funktion JJMASeriesAlert  
//----+ Eingabe der Funktion JMA_ErrDescr  
#include <JJMASeries.mqh> 
//+------------------------------------------------------------------+
//----+ Eingabe der Funktion JurXSeries
//----+ Eingabe der Funktion JurXSeriesResize
//----+ Eingabe der Funktion JurXSeriesAlert 
//----+ Eingabe der Funktion JurX_ErrDescr  
#include <JurXSeries.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+
//| JJurX indicator initialization function                          | 
//+------------------------------------------------------------------+ 
int init() 
{  
//---- Definieren des Zeichenstils vom Chart 
SetIndexStyle (0,DRAW_LINE); 
//---- 1 Indikatorpuffer wurde für die Zählung verwendet 
SetIndexBuffer(0,Ind_Buffer);
//----  Horizontale Verschiebung der Indikator-Linie 
SetIndexShift (0, Shift); 
//---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar werden
SetIndexEmptyValue(0,0); 
//---- Die Namen für Datenfenster und Labels für Unterfenster 
IndicatorShortName ("JJurX( JurX_Length="+JurX_Length+", Shift="+Shift+")"); 
SetIndexLabel (0, "JJurX"); 
//---- Einstellung der Abbildungsgenauigkeit des Indikatorsformats 
IndicatorDigits(Digits);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JurXSeries, 
//      nJurXnumber=2
//(zwei Aufrufe zur Funktion JurXSeries)
if (JurXSeriesResize(2)!=2)return(-1);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JJMASeries,
//      nJMAnumber=1
//(Ein Aufruf zur Funktion JJMASeries)
if (JJMASeriesResize(1)!=1)return(-1);
//---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen  
JurXSeriesAlert(0,"JurX_Length",JurX_Length); 
JJMASeriesAlert(0,"JJMA_Length",JJMA_Length); 
JJMASeriesAlert(1,"JJMA_Phase",JJMA_Phase); 
PriceSeriesAlert(Input_Price_Customs);
//---- Das Ende des Initialisierens 
return(0); 
} 
//+------------------------------------------------------------------+
//| JJurX iteration function                                         | 
//+------------------------------------------------------------------+
int start() 
{ 
//---- Die Überprüfung der Anzahl der Bars, damit sie ausreichend für die Berechnung wären
if (Bars-1<JurX_Length+32)return(0);
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
int reset,MaxBar,counted_bars=IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
if (counted_bars<0)return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden 
//(Ohne diese Neuberechnung für counted_bars wird die Funktion JurXSeries  
// nicht korrekt funktionieren!!!)
if (counted_bars>0) counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//     Es werden alle neue Bars neuberechnet
int limit=Bars-counted_bars-1; 
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//     aller Bars beginnt
MaxBar=Bars-1; 
 
//----+ Die Hauptloop der Berechnung des Indikators 
for(int bar=limit;bar>=0;bar--)
 {
  //----+ Der Aufruf zu der Funktion PriceSeries für die Erhaltung des Eingangspreises
  //       Series
  Price=PriceSeries(Input_Price_Customs,bar);
  //----+ Ein Aufruf zur Funktion JurXSeries nach der Nummer 0. 
  //Der Parameter nJJurX.Length ändert sich nicht an jedem Bar (nJurXdin=0)
  JurX=JurXSeries(0,0,MaxBar,limit,JurX_Length,Price,bar,reset); 
  //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
  if(reset!=0)return(-1); 
  //----+ Definition des Berechnungsfehlers  vom Parameter JurX
  //----+ Der zweite Aufruf zur Funktion JurXSeries nach der Nummer 1. 
  //Der Parameter nJJurX.Length ändert sich nicht an jedem Bar (nJurXdin=0)
  Error=JurXSeries(1,0,MaxBar,limit,JurX_Length,100,bar,reset); 
  //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
  if(reset!=0)return(-1);
  if(Error==0)Error=100;
  JurX*=100/Error;
  //----+ Ein Aufruf zur Funktion JJMASeries nach der Nummer 0. 
  //      Die Parameter nJMA.Phase und nJMA.Length ändern sich nicht an jedem Bar 
  //      (nJMA.din=0)
  JJurX=JJMASeries(0,0,MaxBar,limit,JJMA_Phase,JJMA_Length,JurX,bar,reset);
  //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
  if(reset!=0)return(-1);
  Ind_Buffer[bar]=JJurX;                 
 }
//---- Das Ende der Berechnung der Indikator-Werte
return(0); 
} 
//+-------------------------------------------------------------------------+

In diesem Beispiel sollte die Tatsache beachtet werden, dass die Funktion JurXSeries() sowohl den Eingangspreis auch die Konstante zur Mittelwertbildung führt! Wenn das erhaltende Mittelungsergebnis durch den konstanten Wert geteilt wird, werden wir den Glättungsfehler erhalten. Um ein genaueres Ergebnis der Glättung der Preisreihe zu erhalten, ist es notwendig, das Glättungsergebnis durch diesen Fehlerwert zu teilen. Das wurde eben in unserem Fall getan. In beiden weiteren Fällen werden Zähler und Nenner separat geglättet, so gibt es keine Notwendigkeit, den obigen Vorgang zu wiederholen. Ein solcher Fehler bei anderen Glättungsfunktionen tritt nicht auf.

Das Beispiel des Aufrufs der Funktionen JJMASeries() und JurXSeries() (Analog des Indikators CCI mit zusätzlicher JMA Glättung):

/*
Für  die Arbeit  des Indikators  müssen  die Daten 
JJMASeries.mqh
JurSeries.mqh 
PriceSeries.mqh 
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
*/
//+------------------------------------------------------------------+   
//|                                                        JCCIX.mq4 |
//|                               Copyright © 2006, Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+------------------------------------------------------------------+    
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im getrennten Fenster
#property indicator_separate_window
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers  1
//---- die Farben des Indikators
#property indicator_color1  BlueViolet
//---- Die Parameter der horizontalen Ebenen des Indikators
#property indicator_level1  0.5
#property indicator_level2 -0.5
#property indicator_level3  0.0
#property indicator_levelcolor MediumBlue
#property indicator_levelstyle 4
//---- Eingabeparameter des Indikators 
extern int  JJMA.Length = 8;  // die Glättungstiefe JJMA des Eingangspreises
// die Glättungstiefe JurX des erhaltenden Indikators 
extern int  JurX.Length = 8;
// Der Parameter, der sich im Bereich zwischen -100 ... +100 ändert,  
// beeinflusst auf die Qualität der vorübergehenden Glättungsprozesse 
extern int  JJMA.Phase = 100;
 /* Die Wahl der Preise, nach den der Indikator berechnet wird 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 
11-Heiken Ashi Low, 12-Heiken Ashi High,  13-Heiken Ashi Open, 
14-Heiken Ashi Close.) */
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double Ind_Buffer1[];
//---- Die ganze Konstanten 
int    w;
//+------------------------------------------------------------------+
//----+ Eingabe der Funktion JJMASeries 
//----+ Eingabe der Funktion JJMASeriesResize 
//----+ Eingabe der Funktion JJMASeriesAlert  
//----+ Eingabe der Funktion JMA_ErrDescr  
#include <JJMASeries.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion JurXSeries
//----+ Eingabe der Funktion JurXSeriesResize
//----+ Eingabe der Funktion JurXSeriesAlert 
//----+ Eingabe der Funktion JurX_ErrDescr  
#include <JurXSeries.mqh> 
//+------------------------------------------------------------------+  
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+ 
//| JCCIX initialization function                                    |
//+------------------------------------------------------------------+
int init()
 {
//---- Die Darstellungsarten des Indikators
   SetIndexStyle(0,DRAW_LINE);
//---- 1 Indikatorpuffer wurde für die Zählung verwendet. 
   SetIndexBuffer(0,Ind_Buffer1);
//---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar werden
   SetIndexEmptyValue(0,0); 
//---- Die Namen für Datenfenster und Labels für Unterfenster
   SetIndexLabel(0,"JCCIX");
   IndicatorShortName("JCCIX(JJMA.Length="+JJMA.Length+", JurX.Length"+
                      JurX.Length+")");
//---- Einstellung der Genauigkeit der Format (Die Anzahl der Zeichen nach dem dezimalen Komma) 
//die Indikatorswerte zu visualisieren  
   IndicatorDigits(2);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JurXSeries, 
//      nJurXnumber=2
//(zwei Aufrufe zur Funktion JurXSeries)
   if (JurXSeriesResize(2)!=2)return(-1);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JJMASeries, 
//      nJMAnumber=1
//(Ein Aufruf zur Funktion JJMASeries)
   if (JJMASeriesResize(1)!=1)return(-1);
//---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen
   JurXSeriesAlert (0,"JurX.Length",JurX.Length);
   JJMASeriesAlert (0,"JJMA.Length",JJMA.Length);
   JJMASeriesAlert (1,"JJMA.Phase",JJMA.Phase);
   PriceSeriesAlert(Input_Price_Customs);
//---- Die Bestimmung der Nummer des Bars, von der der Indikator 
//     entsteht  
   SetIndexDrawBegin(0,JurX.Length+31);
//---- Die Initialisierung der Koeffizienten, um Indikator zu berechnen 
   if (JurX.Length>5) w=JurX.Length-1; else w=5;
//---- Das Ende des Initialisierens 
   return(0);
  }
//+------------------------------------------------------------------+
//|  JCommodity Channel IndexX                                       |
//+------------------------------------------------------------------+
int start()
  {
//---- Eingabe der Variablen mit Gleitkomma    
double price,Jprice,JCCIX,UPCCI,DNCCI,JUPCCIX,JDNCCIX; 
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
int reset,MaxBar,MaxBarJ,limit,counted_bars=IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
if (counted_bars<0)return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden 
//---- (Ohne diese Neuberechnung für counted_bars werden die Funktionen JJMASeries 
//und JurXSeries nicht korrekt funktionieren!!!)
if (counted_bars>0) counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung   
//Es wurden alle neue Bars neuberechnet
limit=Bars-counted_bars-1; 
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung   
//alle Bars beginnt
MaxBar=Bars-1; MaxBarJ=MaxBar-30;
//---- Die Korrektur des berechneten Anfangsbars in der Loop
if(limit>=MaxBar)limit=MaxBar;
 
for(int bar=limit; bar>=0; bar--)
 { 
   //----+ Der Aufruf zu der Funktion PriceSeries für die Erhaltung des Eingangspreises 
   //       Series
   price=PriceSeries(Input_Price_Customs, bar);
   //+---------------------------------------------------------------
   //----+ Ein Aufruf zur Funktion JJMASeries nach der Nummer 0 
   //----+ Die Parameter nJMA.Phase und nJMA.Length ändern sich nicht an jedem 
   //      Bar (nJMA.din=0)
   //+---------------------------------------------------------------+   
   Jprice=JJMASeries(0,0,MaxBar,limit,JJMA.Phase,JJMA.Length,price,
                     bar,reset);
   //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
   if(reset!=0)return(-1);
   //+---------------------------------------------------------------+    
   UPCCI=price-Jprice;         
   DNCCI=MathAbs(UPCCI);
   //----+ zwei Aufrufe zur Funktion JurXSeries nach Nummern 0 und 1. 
           Der Parameter nJJurXLength ändert sich nicht 
   //an jedem Bar (nJurXdin=0)
   //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
   JUPCCIX=JurXSeries(0,0,MaxBarJ,limit,JurX.Length,UPCCI,bar,reset); 
   if(reset!=0)return(-1); 
   JDNCCIX=JurXSeries(1,0,MaxBarJ,limit,JurX.Length,DNCCI,bar,reset); 
   if(reset!=0)return(-1); 
   //----+
   if (bar>MaxBarJ-w)JCCIX=0;
   else 
     if (JDNCCIX!=0)
       {
        JCCIX=JUPCCIX/JDNCCIX;
        if(JCCIX>1)JCCIX=1;
        if(JCCIX<-1)JCCIX=-1;
       }
     else JCCIX=0;
   Ind_Buffer1[bar]=JCCIX; 
   //----+
 }
//----
   return(0);
  }
//+-------------------------------------------------------------------+

Die folgende Tatsache sollte beachtet werden: Nach zwei Glättungen mit der Funktion JurXSeries() wird einer erhaltende Wert geprüft, ob der Null nicht gleich ist, weil er ein Nenner ist!

Das Beispiel des Aufrufs der Funktionen JJMASeries() und JurXSeries (Analog des Indikators RSI mit zusätzlicher JMA Glättung):

/*
Für  die Arbeit  müssen  die Daten    
JurXSeries.mqh
JJMASeries.mqh  
PriceSeries.mqh 
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
*/
//+------------------------------------------------------------------+ 
//|                                                        JJRSX.mq4 |
//|    MQL4 JJRSX: Copyright © 2006,                Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+------------------------------------------------------------------+ 
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im getrennten Fenster
#property indicator_separate_window
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers  1
//---- die Farben des Indikators
#property indicator_color1  BlueViolet
//---- Die Parameter der horizontalen Ebenen des Indikators
#property indicator_level1  0.5
#property indicator_level2 -0.5
#property indicator_level3  0.0
#property indicator_levelcolor MediumBlue
#property indicator_levelstyle 4
//---- Eingabeparameter des Indikators 
extern int  Length = 8;  // die Glättungstiefe JurX
// die Glättungstiefe JJMA des erhaltenden Indikators
extern int  Smooth = 3;
// Der Parameter, der sich im Bereich zwischen -100 ... +100 ändert, 
//beeinflusst auf die Qualität der vorübergehenden Glättungsprozesse
extern int  Phase = 100;
/* Die Wahl der Preise, nach den der Indikator berechnet wird 
(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW,
11-Heiken Ashi Low, 12-Heiken Ashi High,  13-Heiken Ashi Open, 
14-Heiken Ashi Close.) */
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double Ind_Buffer[];
//---- Die ganze Variable 
int    w;  
//+------------------------------------------------------------------+  
//----+ Eingabe der Funktion JJMASeries 
//----+ Eingabe der Funktion JJMASeriesResize 
//----+ Eingabe der Funktion JJMASeriesAlert  
//----+ Eingabe der Funktion JMA_ErrDescr  
#include <JJMASeries.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion JurXSeries
//----+ Eingabe der Funktion JurXSeriesResize
//----+ Eingabe der Funktion JurXSeriesAlert 
//----+ Eingabe der Funktion JurX_ErrDescr  
#include <JurXSeries.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+ 
//| JJRSX initialization function                                    |
//+------------------------------------------------------------------+ 
int init()
  {
//---- Die Darstellungsarten des Indikators
   SetIndexStyle(0,DRAW_LINE);
//---- 1 Indikatorpuffer wurde für die Zählung verwendet. 
   SetIndexBuffer(0,Ind_Buffer);
//---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar werden
   SetIndexEmptyValue(0,0); 
//---- Die Namen für Datenfenster und Labels für Unterfenster
   SetIndexLabel(0,"JRSX");
   IndicatorShortName("JRSX(Length="+Length+", Input_Price_Customs="+
                      Input_Price_Customs+")");
//---- Einstellung der Genauigkeit der Format (Die Anzahl der Zeichen nach dem dezimalen 
//     Komma) die Indikatorswerte zu visualisieren  
   IndicatorDigits(2);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JurXSeries,
        nJurXnumber=2
//(zwei Aufrufe zur Funktion JurXSeries)
   if (JurXSeriesResize(2)!=2)return(-1);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion JJMASeries,
        nJMAnumber=1
//(Ein Aufruf zur Funktion JJMASeries)
   if (JJMASeriesResize(1)!=1)return(-1);
//---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen
   JurXSeriesAlert (0,"Length",Length);
   JJMASeriesAlert (0,"Smooth",Smooth);
   JJMASeriesAlert (1,"Phase",Phase);
   PriceSeriesAlert(Input_Price_Customs);
//---- Die Bestimmung der Nummer des Bars, von der der Indikator
       entsteht  
   SetIndexDrawBegin(0,Length+31);
//---- Die Korrektur für nicht akzeptablen Werte des Parameters Length
   if(Length<1)Length=1; 
//---- Die Initialisierung der Koeffizienten, um Indikator zu berechnen 
   if (Length>5) w=Length-1; else w=5;
//---- Das Ende des Initialisierens 
return(0);
  }
//+------------------------------------------------------------------+ 
//| JJRSX iteration function                                         |
//+------------------------------------------------------------------+ 
int start()
{
//---- Eingabe der Variablen mit Gleitkomma 
double dPrice,dPriceA,UPJRSX,DNJRSX,JRSX,JJRSX; 
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
int bar,limit,reset,MaxBar,MaxBarJ,counted_bars=IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
if (counted_bars<0)return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden
if (counted_bars>0) counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//Es werden alle Bars neuberechnet
MaxBar=Bars-2; MaxBarJ=MaxBarJ-w-1; 
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//Es werden alle neue Bars neuberechnet
limit=Bars-counted_bars-1; 
//----+ 
if (limit>MaxBar){limit=MaxBar;Ind_Buffer[MaxBar]=0.0;}
 
for(bar=limit;bar>=0;bar--)
  {
   //----+ zwei Aufrufe zur Funktion PriceSeries für die Erhaltung des Unterschieds 
   //      bei Eingangspreisen dPrice
   dPrice = PriceSeries(Input_Price_Customs, bar)-
                        PriceSeries(Input_Price_Customs, bar+1);
   //----+  
   dPriceA=MathAbs(dPrice);
   //----+ zwei Aufrufe zur Funktion JurXSeries nach Nummern 0 und 1. 
   //      Der Parameter nJJurXLength 
   //ändert sich nicht an jedem Bar (nJurXdin=0) 
   //Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
   UPJRSX=JurXSeries(0,0,MaxBar,limit,Length,dPrice, bar,reset); 
   if(reset!=0)return(-1);
   DNJRSX=JurXSeries(1,0,MaxBar,limit,Length,dPriceA,bar,reset);
   if(reset!=0)return(-1); 
   //----+
   if (bar>MaxBar-w)JRSX=0;
   else if (DNJRSX!=0){JRSX=UPJRSX/DNJRSX;
   if(JRSX>1)JRSX=1;
   if(JRSX<-1)JRSX=-1;}else JRSX=0;
   //+---------------------------------------------------------------+ 
   //----+ Ein Aufruf zur Funktion JJMASeries nach der Nummer 0 
   //----+ Die Parameter nJMA.Phase und nJMA.Length ändern sich nicht an jedem 
   //      Bar (nJMA.din=0)
   //+---------------------------------------------------------------+   
   JJRSX=JJMASeries(0,0,MaxBarJ,limit,Phase,Smooth,JRSX,bar,reset);
   //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
   if(reset!=0)return(-1);
   //+---------------------------------------------------------------+  
   Ind_Buffer[bar]=JJRSX;  
}
//---- Das Ende der Berechnung der Indikator-Werte
return(0);
}
//+------------------------------------------------------------------+



Funktion T3Series()

Das Beispiel des Aufrufs der Funktion T3Series() (3 Bollinger-Bänder mit zusätzlicher Glättung T3):
/*
Für  die Arbeit  des Indikators  müssen  die Daten 
T3Series.mqh 
PriceSeries.mqh 
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
*/
//+------------------------------------------------------------------+ 
//|                                          T3.6Bollinger Bands.mq4 | 
//|                        Copyright © 2006,        Nikolay Kositsin | 
//|                              Khabarovsk,   farria@mail.redcom.ru | 
//+------------------------------------------------------------------+ 
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im Hauptfenster
#property indicator_chart_window 
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers 7
//---- die Farben des Indikators
#property indicator_color1 Gray 
#property indicator_color2 Red
#property indicator_color3 Blue 
#property indicator_color4 Lime
#property indicator_color5 Blue
#property indicator_color6 Red
#property indicator_color7 Gray 
//---- Die Liniensarten des Indikators
#property indicator_style1 4
#property indicator_style2 2
#property indicator_style3 4
#property indicator_style4 4
#property indicator_style5 4
#property indicator_style6 2
#property indicator_style7 4
//---- Eingabeparameter des Indikators 
// Die Periode  der Mittelwertbildung J2Bollinger Bands
extern int        Bands_Period = 100;
extern double Bands_Deviations = 2.0; // Devitation 
extern int         MA_method = 0;   // Die Methode der Mittelwertbildung
// die Glättungstiefe des erhaltenden Moving Avereges
extern int         MA_Smooth = 20;
// die Glättungstiefe des erhaltenden Bollinger Bands
extern int        Bands_Smooth = 20;
// Der Parameter der Glättung, der sich im Bereich zwischen -100 ... +100 ändert, 
//  beeinflusst auf die Qualität des vorübergehenden Prozess; 
extern int    Smooth_Curvature = 100;
// Die Verschiebung des Indikators entlang der Zeitachse 
extern int         Bands_Shift = 0;
//Die Wahl der Preise, nachdem der Indikator berechnet wird 
/*(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW,
11-Heiken Ashi High, 12-Heiken Ashi Low, 13-Heiken Ashi Open, 
14-Heiken Ashi Close.)*/
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double UpperBuffer3  [];
double UpperBuffer2  [];
double UpperBuffer1  [];
double T3MovingBuffer[];
double LowerBuffer1  [];
double LowerBuffer2  [];
double LowerBuffer3  [];
double Series_buffer [];
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion T3Series 
//----+ Eingabe der Funktion T3SeriesResize 
//----+ Eingabe der Funktion T3SeriesAlert 
//----+ Eingabe der Funktion T3_ErrDescr  
#include <T3Series.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+  
//| T3.6Bollinger Bands initialization function        | 
//+------------------------------------------------------------------+  
int init()
  {
//---- Definieren des Zeichenstils vom Chart 
   SetIndexStyle(0,DRAW_LINE); 
   SetIndexStyle(1,DRAW_LINE);
   SetIndexStyle(2,DRAW_LINE);
   SetIndexStyle(3,DRAW_LINE); 
   SetIndexStyle(4,DRAW_LINE);
   SetIndexStyle(5,DRAW_LINE); 
   SetIndexStyle(6,DRAW_LINE);
//---- 4 Indikatorpuffers wurden für die Zählung verwendet  
   IndicatorBuffers(8);
   SetIndexBuffer(0,UpperBuffer3 );
   SetIndexBuffer(1,UpperBuffer2 );
   SetIndexBuffer(2,UpperBuffer1 );
   SetIndexBuffer(3,T3MovingBuffer);
   SetIndexBuffer(4,LowerBuffer1 );
   SetIndexBuffer(5,LowerBuffer2 );
   SetIndexBuffer(6,LowerBuffer3 );
   SetIndexBuffer(7,Series_buffer);
//---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar werden
   SetIndexEmptyValue(0,0);
   SetIndexEmptyValue(1,0);
   SetIndexEmptyValue(2,0);
   SetIndexEmptyValue(3,0);
   SetIndexEmptyValue(4,0);
   SetIndexEmptyValue(5,0);
   SetIndexEmptyValue(6,0);
//---- Die Bestimmung der Nummer des Bars, von der der Indikator
//     entsteht  
   int drawbegin=100+Bands_Shift;
   SetIndexDrawBegin(0,drawbegin);
   SetIndexDrawBegin(1,drawbegin);
   SetIndexDrawBegin(2,drawbegin);
   SetIndexDrawBegin(3,drawbegin);
   SetIndexDrawBegin(4,drawbegin);
   SetIndexDrawBegin(5,drawbegin);
   SetIndexDrawBegin(6,drawbegin);
//---- Horizontale Verschiebung der Indikator-Linien  
   SetIndexShift (0, Bands_Shift); 
   SetIndexShift (1, Bands_Shift); 
   SetIndexShift (2, Bands_Shift); 
   SetIndexShift (3, Bands_Shift); 
   SetIndexShift (4, Bands_Shift); 
   SetIndexShift (5, Bands_Shift); 
   SetIndexShift (6, Bands_Shift); 
//---- Die Namen für Datenfenster und Labels für Unterfenster
   IndicatorShortName ("T3.4Bollinger Bands( Period="+Bands_Period+
        ", Deviations="+Bands_Deviations+")"); 
   SetIndexLabel (0, "Upper3 Bands");
   SetIndexLabel (1, "Upper2 Bands");
   SetIndexLabel (2, "Upper1 Bands"); 
   SetIndexLabel (4, "Lower1 Bands"); 
   SetIndexLabel (5, "Lower2 Bands"); 
   SetIndexLabel (6, "Lower3 Bands"); 
   string Moving;
   switch(MA_method)
       {
        case  0: Moving= "T3SMA";break;
        case  1: Moving= "T3EMA";break;
        case  2: Moving="T3SSMA";break;
        case  3: Moving="T3LWMA";break;
        default: Moving="T3SMA";
       }
   SetIndexLabel (3, "Moving Avereges "+Moving+" ("+Bands_Period+")");
//---- Einstellung der Abbildungsgenauigkeit des Indikatorsformats 
   IndicatorDigits(Digits);
//----+ Die Änderung der Größe bei Puffervariablen der Funktion T3Series, 
//nT3.number=7(7 Aufrufe zur Funktion T3Series)
   if (Bands_Smooth<=1){if (T3SeriesResize(1)!=1)return(-1);}
   else if (T3SeriesResize(7)!=7)return(-1);
//---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen
   T3SeriesAlert(0,"MA_Smooth",MA_Smooth);
   T3SeriesAlert(0,"Bands_Period",Bands_Period);
   PriceSeriesAlert(Input_Price_Customs);
   if((MA_method<0)||(MA_method>3))
        Alert("Der Parameter MA_method muss von 0 bis 3 sein" 
        + " Sie haben nicht akzeptabel eingegeben " 
       +MA_method+ " wird 0 verwendet");
//---- Die Korrektur für nicht akzeptablen Werte des Parameters Bands_Period
   if(Bands_Period<1)Bands_Period=1; 
//---- Das Ende des Initialisierens 
   return(0);
  }
//+------------------------------------------------------------------+  
//| T3.6Bollinger Bands iteration function         | 
//+------------------------------------------------------------------+  
int start()
  {
//---- Die Überprüfung der Anzahl der Bars , damit sie ausreichend für die Berechnung wären
if(Bars-1<=Bands_Period) return(0);
//---- Eingabe der Variablen mit Gleitkomma  
double deviation1,deviation2,deviation3,Temp_Series,sum,midline,
       priceswing,Resalt;
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
int reset,MaxBar,MaxBarBB,MaxBarBB1,bar,kk,counted_bars=IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
if (counted_bars<0)return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden 
// (Ohne diese Neuberechnung für counted_bars wird die Funktion T3Series
// nicht korrekt funktionieren!!!)
if (counted_bars>0) counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung 
//Es werden alle neue Bars neuberechnet
int limit=Bars-counted_bars-1;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//Es werden alle Bars neuberechnet
MaxBar=Bars-1-Bands_Period; MaxBarBB=MaxBar-30-Bands_Period; 
MaxBarBB1=MaxBarBB-1;
//----+ Die Ladung der Eingangspreisen beim Puffer für die Berechnung       
for(bar=limit;bar>=0;bar--)
    Series_buffer[bar]=PriceSeries(Input_Price_Customs,bar);
//---- Die Überprüfung der Anzahl der Bars , damit sie ausreichend für die Berechnung Bollinger Bands wären 
//---- Initialisieren der Null        
if (limit>MaxBar)
     {
      for(bar=limit;bar>=MaxBar;bar--)T3MovingBuffer[bar]=0;
      limit=MaxBar;
     }
//----+ Die Loop der Berechnung Moving Avereges
for(bar=limit;bar>=0;bar--)
     {
      //----+ Die Formel für die Berechnung Moving Avereges
      Temp_Series=iMAOnArray(Series_buffer,0,Bands_Period,0,
                             MA_method, bar);
      //----+ Glättung des erhaltenden Moving Avereges
      //----+ Ein Aufruf zur Funktion T3Series nach der Nummer 0. 
      // Die Parameter nT3.Curvature und nT3.Length ändern sich nicht an jedem 
      // Bar (nT3.din=0)
      Resalt=T3Series(0,0,MaxBar,limit,Smooth_Curvature,MA_Smooth,
                      Temp_Series,bar,reset);
      //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
      if(reset!=0)return(-1); 
      T3MovingBuffer[bar]=Resalt; 
     }     
//---- Die Berechnung Bollinger Bands 
//---- Initialisieren der Null      
if (limit>MaxBarBB)
     {
      for(bar=limit;bar>=MaxBarBB;bar--)
       {
        UpperBuffer2[bar]=0;
        UpperBuffer1[bar]=0;
        LowerBuffer1[bar]=0;
        LowerBuffer2[bar]=0;
       }
      limit=MaxBarBB;
     }
for(bar=limit;bar>=0;bar--)
   {       
     sum=0.0;
     midline=T3MovingBuffer[bar];
     kk=bar+Bands_Period-1;
     while(kk>=bar)
      {
       priceswing=PriceSeries(Input_Price_Customs,kk)-midline;
       sum+=priceswing*priceswing;
       kk--;
      }
     deviation2=Bands_Deviations*MathSqrt(sum/Bands_Period);     
     deviation1=0.5*deviation2;
     deviation3=1.5*deviation2;
     if (Bands_Smooth>1)
      {
       //----+ Die Berechnung und T3 die Glättung Bollinger Bands      
       //----+ ------------------------------------------------------+        
       //----+ 7 parallele Aufrufe zur Funktion T3Series 
       //      nach Nummern 1, 2, 3, 4, 5, 6. 
       //----+ Die Parameter nT3.Length ändern sich nicht an jedem Bar 
       //      (nT3.din=0)
       //----+ ------------------------------------------------------+ 
       Resalt=T3Series(1,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline+deviation3,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       UpperBuffer3[bar]=Resalt; 
       //----+ ------------------------------------------------------+ 
       Resalt=T3Series(2,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline+deviation2,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       UpperBuffer2[bar]=Resalt; 
       //----+ ------------------------------------------------------+       
       Resalt=T3Series(3,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline+deviation1,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       UpperBuffer1[bar]=Resalt; 
       //----+ ------------------------------------------------------+ 
       Resalt=T3Series(4,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline-deviation1,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       LowerBuffer1[bar]=Resalt; 
       //----+ ------------------------------------------------------+ 
       Resalt=T3Series(5,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline-deviation2,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       LowerBuffer2[bar]=Resalt; 
       //----+ ------------------------------------------------------+ 
       Resalt=T3Series(6,0,MaxBarBB1,limit,Smooth_Curvature,Bands_Smooth,
                       midline-deviation3,bar,reset);
       //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
       if(reset!=0)return(-1); 
       LowerBuffer3[bar]=Resalt;        
       //----+ ------------------------------------------------------+ 
      }
     else 
      {
       //----+ Die Berechnung Bollinger Bands ohne T3 Glättung 
       UpperBuffer3[bar]=midline+deviation3; 
       UpperBuffer2[bar]=midline+deviation2;
       UpperBuffer1[bar]=midline+deviation1;
       LowerBuffer1[bar]=midline-deviation1;
       LowerBuffer2[bar]=midline-deviation2;
       LowerBuffer3[bar]=midline-deviation3;
      }
      
   }
//---- Das Ende der Berechnung der Indikator-Werte
   return(0);
  }
//+-------------------------------------------------------------------+



Funktion ParMASeries()

Das Beispiel des Aufrufs der Funktion ParMASeries() (ParMA Muving mit zusätzlicher Glättung JMA):

/*
Der gleitende Mittelwert ParMA, der auf Basis der parabolischen 
Regression mit Bändern berechnet ist 
 
Für  die Arbeit  des Indikators  müssen  die Daten 
JJMASeries.mqh 
ParMASeries.mqh 
PriceSeries.mqh 
im Verzeichnis: MetaTrader\experts\include\ abgelegt werden 
Heiken Ashi#.mq4
im Verzeichnis: MetaTrader\indicators\
*/
//+------------------------------------------------------------------+ 
//|                                                       JParMA.mq4 |
//|                       ParMA MQL4 CODE: Copyright © 2006, alexjou |
//|             JParMA Indicator: Copyright © 2006, Nikolay Kositsin |
//+------------------------------------------------------------------+ 
#property copyright "Copyright © 2006, Nikolay Kositsin"
#property link "farria@mail.redcom.ru" 
//---- Darstellung des Indikators im Hauptfenster
#property indicator_chart_window
//---- die Anzahl der Indikatorpuffers
#property indicator_buffers 1
//---- die Farbe des Indikators 
#property indicator_color1 Red
//---- Eingabeparameter des Indikators 
extern int MA_Period  = 8; // Die Periode ParMA
extern int Length = 3;   // Die Glättungstiefe 
// Der Parameter, der sich im Bereich zwischen -100 ... +100 ändert, 
//beeinflusst auf die Qualität des vorübergehenden Prozess; 
extern int Phase  = 100;
extern int Shift  = 0;   // Die Verschiebung des Indikators entlang der Zeitachse 
//Die Wahl der Preise, nachdem der Indikator berechnet wird 
/*(0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED,
7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 
11-Heiken Ashi High, 12-Heiken Ashi Low, 13-Heiken Ashi Open, 
14-Heiken Ashi Close.) */
extern int Input_Price_Customs = 0;
//---- Indikatorpuffers
double IndBuffer[];
//---- die Variablen mit Gleitkomma 
double JResalt, Price, Resalt;
//+------------------------------------------------------------------+  
//----+ Eingabe der Funktion JJMASeries 
//----+ Eingabe der Funktion JJMASeriesResize 
//----+ Eingabe der Funktion JJMASeriesAlert  
//----+ Eingabe der Funktion JMA_ErrDescr  
#include <JJMASeries.mqh> 
//+------------------------------------------------------------------+ 
//----+ Eingabe der Funktion ParMAMASeries 
//----+ Eingabe der Funktion ParMASeriesResize 
//----+ Eingabe der Funktion ParMASeriesAlert 
//----+ Eingabe der Funktion ParMA_ErrDescr 
#include <ParMASeries.mqh> 
//+------------------------------------------------------------------+  
//----+ Eingabe der Funktion PriceSeries
//----+ Eingabe der Funktion PriceSeriesAlert 
#include <PriceSeries.mqh>
//+------------------------------------------------------------------+   
//| JParMA initialization function                                   |
//+------------------------------------------------------------------+ 
int init()
 {
  //---- Einstellung der Abbildungsgenauigkeit des Indikatorsformats 
  IndicatorDigits(Digits);
  //---- Definieren des Zeichenstils vom Chart 
  SetIndexStyle(0, DRAW_LINE);
  //---- 1 Indikatorpuffer wurde für die Zählung verwendet 
  SetIndexBuffer(0, IndBuffer);
  //----  Horizontale Verschiebung der Indikator-Linie 
  SetIndexShift (0, Shift); 
  //---- Die Einstellung der Indikator-Werten, die im Chart unsichtbar
  //     werden
  SetIndexEmptyValue(0, 0.0); 
  //---- Die Namen für Datenfenster und Labels für Unterfenster 
  IndicatorShortName ("JParMA( Length="+Length+", Phase="+Phase+", Shift="+Shift+")");   
  SetIndexLabel(0, "JParMA Line");
  //---- Die Bestimmung der Nummer des Bars, von der der Indikator
         entsteht 
  SetIndexDrawBegin(0, MA_Period);
  //----+ Die Änderung der Größe bei Puffervariablen der Funktion JJMASeries, 
  //nJMAnumber=1(Ein Aufruf zur Funktion JJMASeries)
  if (JJMASeriesResize(1)!=1)return(-1);
  //----+ Die Änderung der Größe bei Puffervariablen der Funktion ParMASeries, 
  //nParMAnumber=1(Ein Aufruf zur Funktion ParMASeries)
  if (ParMASeriesResize(1)!=1)return(-1);
  //---- Einstellung der Warnungen für nicht akzeptablen Werte der externen Variablen
  JJMASeriesAlert (0,"Length",Length);
  JJMASeriesAlert (1,"Phase", Phase );
  ParMASeriesAlert(0,"MA_Period",MA_Period);
  PriceSeriesAlert(Input_Price_Customs);
  return(0);
 }
//+------------------------------------------------------------------+ 
//| JParMA iteration function                                        |
//+------------------------------------------------------------------+ 
int start()
 {
 //---- Die Überprüfung der Anzahl der Bars , damit sie ausreichend für die Berechnung wären
if (Bars-1<MA_Period)return(0);
//----+ Eingabe der ganzen Variablen und erhalten dadurch bereits berechneten Bars
int reset,MaxBar,MaxBarP,bar,Limit,counted_bars=IndicatorCounted();
//---- Überprüfung auf mögliche Fehler
if (counted_bars<0)return(-1);
//---- das letzte berechnete Bar muss neuberechnet werden 
if (counted_bars>0) counted_bars--;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//Es werden alle Bars neuberechnet
MaxBar=Bars-1; MaxBarP=MaxBar-MA_Period;
//---- Die Bestimmung der Nummer des letzten Bars, von dem die Neuberechnung  
//Es werden alle neue Bars neuberechnet 
Limit=Bars-counted_bars-1; 
 
//---- Die Berechnung des Indikators
for (bar=Limit; bar>=0; bar--)
   { 
    //----+ 
     Price=PriceSeries(Input_Price_Customs,bar);
     //----+ Die Erhaltung des Anfangsindikators
     //----+ Ein Aufruf zur Funktion ParMASeries nach der Nummer 0
     Resalt=ParMASeries(0,MaxBar,Limit,MA_Period,Price,bar,reset); 
     //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
     if(reset!=0)return(-1);
     //----+ JMA die Glättung des erhaltenden Indikators, 
     //der Parameter nJMA.MaxBar wurde um MA_Period verringert 
     //----+ Ein Aufruf zur Funktion JJMASeries зnach der Nummer 0, 
     // Die Parameter nJMA.Phase und nJMA.Length ändern sich nicht an jedem Bar
     // (nJMA.din=0)
     JResalt=JJMASeries(0,0,MaxBarP,Limit,Phase,Length,Resalt,bar,reset);
     //----+  Überprüfung auf die Abwesenheit des Fehlers in der vorherigen Operation
     if(reset!=0)return(-1);
     IndBuffer[bar]=JResalt;
   }
 //----
  return(0);
 }
 //+-------------------------------------------------------------------+
An allen Indikatoren wird die Funktion PriceSeries() statt dem normalerweise angewendeten Array von der Zeitanordnung Close[] verwendet, bei deren Anwendung kein Problem auftreten soll:
double  PriceSeries(int Input_Price_Customs, int bar)

Der Eingabeparameter Input_Price_Customs kann sich von 0 bis 14 ändern. Abhängig vom Wert dieses Parameters liefert die Funktion die Preiswerte für das aktuelle Chart nach der Nummer des Bars, der als zweite Parameter angewendet wird: 0-CLOSE, 1-OPEN, 2-HIGH, 3-LOW, 4-MEDIAN, 5-TYPICAL, 6-WEIGHTED, 7-Heiken Ashi Close, 8-SIMPL, 9-TRENDFOLLOW, 10-0.5*TRENDFOLLOW, 11-Heiken Ashi High, 12-Heiken Ashi Low, 13-Heiken Ashi Open, 14-Heiken Ashi Close. Wenn es notwendig ist, kann man in der Funktion andere algebraische Daten schreiben, um die Eingangspreise basierend auf Arrays der Zeitreihenanordnungen zu definieren. Die Indikatoren mit der Verwendung der Funktion PriceSeries() sind sehr bequem bei der Optimierung und dem Test der Experten.


Fazit

Im Archiv NK_library.zip sind über 100 Indikatoren, die mit der Verwendung dieser Algorithmen geschrieben wurden. Diese Beispiele sind mehr als genug, um die erwähnten Funktionen zu verwenden, und dadurch andere Indikatoren zu schreiben. Alle Indikatoren aus dem Archiv mit diesen Versionen der Glättungsfunktionen funktionieren mit Experten ohne Fehler. Außer der Indikatoren mit den Namen, deren Name-ende mit HTF beendet. Diese Indikatoren wegen ihrer Berechnungsweise können mit Experten nicht zusammen verwendet werden! Die Indikatoren aus dem Archiv muss im Ordner des Client-Terminals: \MetaTrader\EXPERTS\indicators gespeichert werden. Die Funktionen werden im Archiv des Ordners INCLUDE sein. Den ganzen Inhalt dieses Ordners muss im Ordner des Client-Terminals: \MetaTrader\EXPERTS\INCLUDE gespeichert werden.



Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1450

Beigefügte Dateien |
NK_library.zip (1939.17 KB)
Die Funktionalität MetaTrader 4 unter Antiviren und Firewalls Die Funktionalität MetaTrader 4 unter Antiviren und Firewalls

Die meisten Händler verwenden spezielle Programme, um ihre PCs zu schützen. Leider schützen diese Programme den Computer nicht nur vor dem Eindringen der Viren und Trojaner, sondern auch verbrauchen viele Ressourcen. Dies betrifft vor allem den Netztrafik, der durch verschiedene intelligente Antiviren-Programme und Firewalls völlig kontrolliert wird. Den Anstoß zum Schreiben des Artikels haben die Beschweren der Händler über die Verlangsamung des MetaTrader 4 Kundenterminals beim Arbeiten mit Outpost Firewall gegeben. Wir haben uns entschieden, die Programme Kaspersky Antivirus 6.0 und Outpost Firewall Pro 4.0 selbst zu testen.

Fehler bei der Arbeit eines Traderanfängers im Client Terminal MetaTrader 4 Fehler bei der Arbeit eines Traderanfängers im Client Terminal MetaTrader 4

Irren ist menschlich. Jeder irrt, häufiger oder seltener, aus Unwissenheit oder aus Versehen. Sie fragen - wir antworten: Zeit im Terminal, Testergebnisse, Print im Journal, Symbole, Historie für den Tester, Übertragung der Historie, Hebel, Trafik, Popup-Fenster, Skalierung, falsches Konto, Invalid account, leere Nachrichten, Price changed, Not Enough Money, Market Is Closed.

Die Realisierung der dreifarbigen Indikatoren und einige Möglichkeiten für eine maximale Vereinfachung des Indikatoren-Schreibens Die Realisierung der dreifarbigen Indikatoren und einige Möglichkeiten für eine maximale Vereinfachung des Indikatoren-Schreibens

In diesem Artikel betrachtet der Autor einige Methoden zur Erhöhung der Informativität für visuelles Trading. Der Autor analysiert die Realisierung der dreifarbigen Indikatoren, bei deren Aufbau die Daten aus anderen Zeitrahmen verwendet werden, und geht weiter auf die Bibliothek der Indikatoren ein, die bereits im Artikel "Effektive Mittelwertbildungsalgorithmen mit minimalen Lags und ihre Verwendung in Indikatoren" erwähnt wurde.

ABC Trading im Forex ABC Trading im Forex

Die Arbeit auf den Finanzmärkten besteht vor allem aus Handelsoperationen. Wir haben alle von der Kindheit eine intuitive Vorstellung vor den Operationen, bei denen es um Kaufen und Verkaufen geht. Aber das Trading im Forex hat seine eigene Besonderheit. In diesem Artikel werden wir die notwendigen Begriffe betrachten, die einige Fachausdrücke erklären. Wir werden auch die MQL4-Funktionen berücksichtigen, die mit diesen Begriffen entsprechen.