MetaTrader 5 / 交易
English Русский Español Deutsch 日本語 Português 한국어 Français Italiano Türkçe
preview
从头开始开发智能交易系统（第 19 部分）：新订单系统 (II)

从头开始开发智能交易系统（第 19 部分）：新订单系统 (II)

MetaTrader 5 — 交易 |
1 257 1
Daniel Jose
Daniel Jose

概述

在上一篇文章中，从头开始开发交易专家顾问（第 18 部分），我们在订单系统中实现了一些修复、更改和调整，旨在创建一个系统，能够在净持和对冲不同结算类型的账户里执行交易，因为账户操作存在差异。 对于净持结算类型，系统生成一个平均价格，且每种资产只能有一笔持仓。 在对冲账户中，您可以有多笔持仓，每笔持仓都有各自的限定。 您可以同时买卖相同的资产。 这样的操作只能在对冲账户上进行。 这是了解期权交易的基础。

但现在是时候令订单系统完全可视化了，这样我们就可以剔除消息框，且在不借助它的情况下分析每笔持仓的数值。 我们可以通过新的订单系统来做到这一点。 这将允许我们一次调整若干件事情。 此外，由于 EA 将实时显示相关信息，不需要任何额外计算，我们就能够轻松了解 OCO 订单或挂单的盈亏限额。

虽然这只是第一部分的实现，但我们并不是从头开始：我们将修改现有系统，往正在交易的资产图表里添加更多对象和事件。


1.0. 计划

我们在这里所用的系统规划并不特别困难：我们将修改现有系统，只更改图表上表示订单的系统。 这是主要思路，看起来十分简单。 但实际上，这需要很强的创造力，因为我们要操纵和数据建模，从而 MetaTrader 5 平台能替我们完成所有的艰苦工作。

有若干种方法可对数据建模，每种方法都有其优缺点。

  • 第一种方法是使用列表。 它可以是单循环、双循环，甚至是哈希系统。 使用任何这些方式的优点是系统易于实现。 然而，缺点则是要防止数据操纵或限制订单数量。 甚而，在这种情况下，我们必须创建保存列表的所有额外逻辑。
  • 第二种方式是创建类数组，而类将包含并维护所有新创建的对象。 在这种情况下，数组将像列表一样工作，但我们必须编写少量代码，因为 MQL5 已经支持在使用列表的情况下原来必须编写代码的一些东西。 然而，我们会有其它问题，例如事件处理，在这种状况下，事情会变得非常困难。
  • 第三种方式是我们将要采取的方式。 我们将强制以 MQL5 创建代码来支持动态对象。 这似乎看起来有些不现实，但如果我们针对所用数据进行正确建模，那么 MQL5 语言将令我们能够创建一个系统，且其对屏幕上的对象数量没有限制。 甚至，所有对象都将能够生成和接收事件。 尽管它们有各自的特点，但平台将看到它们都链接起来，就像它们在列表或数组索引中一样。

如果您认为这不太容易实现，请查看 C_HLineTrade 类的以下代码部分：

inline void SetLineOrder(ulong ticket, double price, eHLineTrade hl, bool select)
{
        string sz0 = def_NameHLineTrade + (string)hl + (string)ticket, sz1;
                                
        ObjectCreate(Terminal.Get_ID(), sz0, OBJ_HLINE, 0, 0, 0);

//... The rest of the code....

高亮显示的部分准确地向我们展示了可以创建任意数量的水平线，它们将以完全独立的方式接收事件。 我们所有需要做的就是根据每一行的名称实现事件，因为名称是唯一的。 MetaTrader 5 平台将负责剩下的工作。 结果大约如下所示：


虽然这看起来已经很理想了，但这样建模不足以实现我们真正需要的结果。 这个思路已经可以实现。 但 EA 中当前可用的数据建模并不理想，因为我们不能基于一个名称拥有无限数量的对象。 我们需要进行一些修改，而这需要相当深入地修改代码。

我们现在将开始实现这种新的数据建模方法，但我们只是简单地修改必要的内容，同时保持整体代码的稳定，因为它应该尽可能稳定地继续工作。 所有操作将由 MetaTrader 5 平台执行，我们仅指示平台应如何理解我们的建模。


2.0. 实现

第一处修改是将 C_HLineTrade 更改为新的 C_ObjectsTrade 类。 这个新类将能够支持我们所需要的 — 能够链接无限数量对象的一种方法。

我们先看看下面代码中的原始定义。

class C_ObjectsTrade
{
//+------------------------------------------------------------------+
#define def_NameObjectsTrade 	"SMD_OT"
#define def_SeparatorInfo       '*'
#define def_IndicatorTicket0    1
//+------------------------------------------------------------------+
        protected:
                enum eIndicatorTrade {IT_NULL, IT_STOP= 65, IT_TAKE, IT_PRICE};
//+------------------------------------------------------------------+

// ... The rest of the class code

此处我们有了我们将要实现的初始基础。 它在未来将得到扩展，但目前我希望系统保持稳定，尽管它正在被修改，并具有新的数据建模。

即使在受保护部分声明中，我们也拥有以下函数：

inline double GetLimitsTake(void) const { return m_Limits.TakeProfit; }
//+------------------------------------------------------------------+
inline double GetLimitsStop(void) const { return m_Limits.StopLoss; }
//+------------------------------------------------------------------+
inline bool GetLimitsIsBuy(void) const { return m_Limits.IsBuy; }
//+------------------------------------------------------------------+
inline void SetLimits(double take, double stop, bool isbuy)
{
        m_Limits.IsBuy = isbuy;
        m_Limits.TakeProfit = (m_Limits.TakeProfit < 0 ? take : (isbuy ? (m_Limits.TakeProfit > take ? m_Limits.TakeProfit : take) : (take > m_Limits.TakeProfit ? m_Limits.TakeProfit : take)));
        m_Limits.StopLoss = (m_Limits.StopLoss < 0 ? stop : (isbuy ? (m_Limits.StopLoss < stop ? m_Limits.StopLoss : stop) : (stop < m_Limits.StopLoss ? m_Limits.StopLoss : stop)));
}
//+------------------------------------------------------------------+
inline int GetBaseFinanceLeveRange(void) const { return m_BaseFinance.Leverange; }
//+------------------------------------------------------------------+
inline int GetBaseFinanceIsDayTrade(void) const { return m_BaseFinance.IsDayTrade; }
//+------------------------------------------------------------------+
inline int GetBaseFinanceTakeProfit(void) const { return m_BaseFinance.FinanceTake; }
//+------------------------------------------------------------------+
inline int GetBaseFinanceStopLoss(void) const { return m_BaseFinance.FinanceStop; }

目前，这些函数只是作为未来我们将要实现的另一个方案的保险措施。 尽管我们可以在另一个位置实现数据和解析，但最好尽可能在继承链底层保留一些东西。 即使返回值仅由派生类取用，我也不愿允许这样直接：我不想让派生类访问 C_ObjectsTrade 对象类中的值，因为这将打破对象类封装的思想，如果派生类在不经由过程调用的情况下就能变更相关基类的值，这令未来的修改或错误修复变得困难。

为了尽可能减少调用重叠，所有函数都声明为内联：这稍微增加了可执行文件的大小，但会导致更安全的系统。

现在我们来到私密声明。

//+------------------------------------------------------------------+
        private :
                string  m_SelectObj;
                struct st00
                {
                        double  TakeProfit,
                                StopLoss;
                        bool    IsBuy;
                }m_Limits;
                struct st01
                {
                        int     FinanceTake,
                                FinanceStop,
                                Leverange;
                        bool    IsDayTrade;
                }m_BaseFinance;
//+------------------------------------------------------------------+
                string MountName(ulong ticket, eIndicatorTrade it)
                {
                        return StringFormat("%s%c%c%c%d", def_NameObjectsTrade, def_SeparatorInfo, (char)it, def_SeparatorInfo, ticket);
                }
//+------------------------------------------------------------------+

最重要的部分是高亮显示的片段，它将建模对象的名称。 我保留了一些基础，它们在系统中仍然可用。 这是因为我们首先创建和修改建模，保持系统稳定。 然后我们将添加新对象，而这将非常容易、快速地完成。 甚至，我们将保持已经实现的稳定。

虽然代码经历了比这里所示更多的变化，但我只关注新函数，以及与以前代码相比变化相当大的部分。

第一个函数如下所示：

inline string CreateIndicatorTrade(ulong ticket, eIndicatorTrade it, bool select)
{
        string sz0 = MountName(ticket, it);
                                
        ObjectCreate(Terminal.Get_ID(), sz0, OBJ_HLINE, 0, 0, 0);
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_COLOR, (it == IT_PRICE ? clrBlue : (it == IT_STOP ? clrFireBrick : clrForestGreen)));
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_WIDTH, 1);
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_STYLE, STYLE_DASHDOT);
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_SELECTABLE, select);
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_SELECTED, false);
        ObjectSetInteger(Terminal.Get_ID(), sz0, OBJPROP_BACK, true);
        ObjectSetString(Terminal.Get_ID(), sz0, OBJPROP_TOOLTIP, (string)ticket + " "+StringSubstr(EnumToString(it), 3, 10));
                                
        return sz0;
}

目前，它只会创建一条水平线。 注意名称生成代码；还要注意，颜色现在将由代码内部定义，而不是由用户定义。

然后我们重载相同的函数，如下所示。

inline string CreateIndicatorTrade(ulong ticket, double price, eIndicatorTrade it, bool select)
{
        if (price <= 0)
        {
                RemoveIndicatorTrade(ticket, it);
                return NULL;
        }
        string sz0 = CreateIndicatorTrade(ticket, it, select);
        ObjectMove(Terminal.Get_ID(), sz0, 0, 0, price);
                                
        return sz0;
}

不要把这两个函数混淆，因为尽管它们看起来一样，但实际上不同。 重载非常常见：我们创建一个简单的函数，然后往其中添加新参数，以便累积某种类型的建模。 如果我们没有通过重载实现它，我们有时将不得不重复相同的代码。 这很危险，因为我们会忘记声明一些东西。 此外，这也不太实用，因此我们重载的函数只需调用一个，取代调用若干个。

于此应提到的一件事是第二个版本中高亮显示的部分。 不需要在此处创建它，我们可以在其它地方做这件事。 但是，正如所见，当我们尝试以零价格创建一些对象时，实际上它必须被销毁。

为了实际查看发生这种情况的时刻，请查看下面的代码：

class C_Router : public C_ObjectsTrade
{

// ... Internal class code ....

                void UpdatePosition(int iAdjust = -1)
                        {

// ... Internal function code ...

                                for(int i0 = p; i0 >= 0; i0--) if(PositionGetSymbol(i0) == Terminal.GetSymbol())
                                {
                                        ul = PositionGetInteger(POSITION_TICKET);
                                        m_bContainsPosition = true;
                                        CreateIndicatorTrade(ul, PositionGetDouble(POSITION_PRICE_OPEN), IT_PRICE, false);
                                        CreateIndicatorTrade(ul, take = PositionGetDouble(POSITION_TP), IT_TAKE, true);
                                        CreateIndicatorTrade(ul, stop = PositionGetDouble(POSITION_SL), IT_STOP, true);

// ... The rest of the code...

每次 EA 收到 OnTrade 事件时，它将执行上述函数，并尝试在选定点上创建一个指标，但如果用户删除限制，则该指标将变为零。 因此，当调用时，它实际上会从图表中删除指标，内存中已无用的对象也可为我们节省下来。 由此，我们在某些方面有所收获，因为检查将在创建时刻正确完成。

但我们仍然有重载的问题，因为有些人可能不完全理解在实际中如何使用代码。 为了理解这一点，请查看以下两段代码：

class C_OrderView : public C_Router
{
        private  :
//+------------------------------------------------------------------+
        public   :
//+------------------------------------------------------------------+
                void InitBaseFinance(int nContracts, int FinanceTake, int FinanceStop, bool b1)
                        {                       
                                SetBaseFinance(nContracts, FinanceTake, FinanceStop, b1);
                                CreateIndicatorTrade(def_IndicatorTicket0, IT_PRICE, false);
                                CreateIndicatorTrade(def_IndicatorTicket0, IT_TAKE, false);
                                CreateIndicatorTrade(def_IndicatorTicket0, IT_STOP, false);
                        }
//+------------------------------------------------------------------+

// ... Rest of the code...
class C_Router : public C_ObjectsTrade
{

// ... Class code ...

                void UpdatePosition(int iAdjust = -1)
                        {
// ... Function code ....
                                for(int i0 = p; i0 >= 0; i0--) if(PositionGetSymbol(i0) == Terminal.GetSymbol())
                                {
                                        ul = PositionGetInteger(POSITION_TICKET);
                                        m_bContainsPosition = true;
                                        CreateIndicatorTrade(ul, PositionGetDouble(POSITION_PRICE_OPEN), IT_PRICE, false);

// ... The rest of the code...

请注意，在这两种情况下，我们所用的函数名称相同。 此外，它们都是同一个 C_ObjectsTrade 类的一部分。 然而，即使在这种情况下，编译器也可能区分它们，这是由于参数的数量。 如果您仔细观察，就会发现唯一的区别是一个额外的 “price” 参数，但也许还有其它一些参数。 正如您所看到的，调用一个 N 合一的重载版本要比复制所有代码要容易得多，如此最终我们得到了更干净的代码，更易于维护。

现在我们回到 C_ObjectsTrade 类。 下一个我们需要理解的函数如下：

bool GetInfosOrder(const string &sparam, ulong &ticket, double &price, eIndicatorTrade &it)
{
        string szRet[];
        char szInfo[];
                                
        if (StringSplit(sparam, def_SeparatorInfo, szRet) < 2) return false;
        if (szRet[0] != def_NameObjectsTrade) return false;
        StringToCharArray(szRet[1], szInfo);
        it = (eIndicatorTrade)szInfo[0];
        ticket = (ulong) StringToInteger(szRet[2]);
        price = ObjectGetDouble(Terminal.Get_ID(), sparam, OBJPROP_PRICE);
                                
        return true;
}

事实上，它是整个新系统的心脏、大脑和身体。 虽然它看起来很简单，但它所做的工作对于整个 EA 来说是至关重要的，因为我们的新建模系统需要它。

密切注意高亮显示的代码，特别是 StringSplit 函数。 如果它在 MQL5 中不存，我们就必须为其进行编码。 幸运的是，MQL5 已拥有它，因此我们就可充分利用这个函数。 它所做的就是将对象的名称分解为所需的数据。 当创建对象名称时，它以非常特定的方式建模，因此我们可以撤消此编码模型，因此 StringSplit 将撤消 StringFormat 函数所做的工作。

函数的其余部分捕获对象名称中存在的数据，以便我们稍后测试和使用。 也就是说，MetaTrader 5 为我们生成数据，我们对数据进行分解，以便探知发生了什么，然后告诉 MetaTrader 5 应该采取哪些步骤。 我们的目的是让 MetaTrader 5 为我们工作。 我不会从头开始创建模型；取而代之，我会从零开始为界面和 EA 建模。 因此，我们应该从 MetaTrader 5 提供的支持当中受益，而不必寻找外部解决方案。

在下面的代码中，我们将完成与上面所做的非常类似的操作：

inline void RemoveAllsIndicatorTrade(bool bFull)
{
        string sz0, szRet[];
        int i0 = StringLen(def_NameObjectsTrade);
                                
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, false);
        for (int c0 = ObjectsTotal(Terminal.Get_ID(), -1, -1); c0 >= 0; c0--)
        {
                sz0 = ObjectName(Terminal.Get_ID(), c0, -1, -1);
                if (StringSubstr(sz0, 0, i0) == def_NameObjectsTrade)
                {
                        if (!bFull)
                        {
                                StringSplit(sz0, def_SeparatorInfo, szRet);
                                if (StringToInteger(szRet[2]) == def_IndicatorTicket0) continue;
                        }
                }else continue;                                         
                ObjectDelete(Terminal.Get_ID(), sz0);
        }
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, true);
}

每次我们从图表中删除一条线，无论是要平仓，亦或是要删除的限价等级，都必须删除相应的对象，就像从图表中移除 EA 一样。 我们需要删除这些对象，但我们也要有一组标线，除非绝对必要，否则不应删除：这是 Ticket0，除非非常必要，否则不得删除。 为了避免将其删除，我们要把代码高亮显示。 如果没有这个，我们每次都需要重新创建这个 Ticket0，因为这个 ticket 在另一个代码部分中非常重要，我们将在后面讨论。

在所有其它时间，我们需要删除一些特定的内容。 为此，我们将调用另一个移除函数，如下所示。

inline void RemoveIndicatorTrade(ulong ticket, eIndicatorTrade it = IT_NULL)
{
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, false);
        if ((it != NULL) && (it != IT_PRICE))
                ObjectDelete(Terminal.Get_ID(), MountName(ticket, it));
        else
        {
                ObjectDelete(Terminal.Get_ID(), MountName(ticket, IT_PRICE));
                ObjectDelete(Terminal.Get_ID(), MountName(ticket, IT_TAKE));
                ObjectDelete(Terminal.Get_ID(), MountName(ticket, IT_STOP));
        }
        ChartSetInteger(Terminal.Get_ID(), CHART_EVENT_OBJECT_DELETE, true);
}

下一个新例程如下所示：

inline void PositionAxlePrice(double price, ulong ticket, eIndicatorTrade it, int FinanceTake, int FinanceStop, int Leverange, bool isBuy)
{
        double ad = Terminal.GetAdjustToTrade() / (Leverange * Terminal.GetVolumeMinimal());
        ObjectMove(Terminal.Get_ID(), MountName(ticket, it), 0, 0, price);
        if (it == IT_PRICE)
        {
                ObjectMove(Terminal.Get_ID(), MountName(ticket, IT_TAKE), 0, 0, price + Terminal.AdjustPrice(FinanceTake * (isBuy ? ad : (-ad))));
                ObjectMove(Terminal.Get_ID(), MountName(ticket, IT_STOP), 0, 0, price + Terminal.AdjustPrice(FinanceStop * (isBuy ? (-ad) : ad)));
        }
}

它将在价格轴上放置对象。 但不要太依附于它，因为它很快会因为各种原因而不复存在。 它们当中之一是我们在本系列的另一篇文章中谈到的：一个图表上的多个指标（第 05 部分）：将 MetaTrader 5 转换为 RAD（I）系统。 本文带有一个表格，显示了可以使用笛卡尔坐标进行定位的对象，这些坐标是 X 和 Y。价格和时间坐标尽管在某些情况下很有用，但并非始终方便：当我们想要在屏幕上的某些点上定位元素时，尽管使用价格和时间座标开发东西会更快，它们比 X 和 Y 系统更难精确定位。

我们将在下一次进行修改，而现在我们的目的是创建一个替代目前所用的系统。

接下来，我们在 C_ObjectsTrade 类中有最后一个重要函数。 代码如下所示：

inline double GetDisplacement(const bool IsBuy, const double Vol, eIndicatorTrade it) const
{
        int i0 = (it == IT_TAKE ? m_BaseFinance.FinanceTake : m_BaseFinance.FinanceStop),
            i1 = (it == IT_TAKE ? (IsBuy ? 1 : -1) : (IsBuy ? -1 : 1));
        return (Terminal.AdjustPrice(i0 * (Vol / m_BaseFinance.Leverange) * Terminal.GetAdjustToTrade() / Vol) * i1);
}

此函数会把在图表交易者中指定的挂单或市价开仓的数值进行转换。

所有这些修改都是为了实现将 C_HLineTrade 函数转换为 C_ObjectsTrade。 然而，这些变更还需要一些其它修改。 例如，有些类也发生了显著变化，如 C_ViewOrder。 这个类的某些部分不复存在，因为它们的存在没有意义，而其余的函数已经改变。 某些值得特别注意的函数如下高亮所示。

第一个是初始化来自图表交易者的数据的函数。

void InitBaseFinance(int nContracts, int FinanceTake, int FinanceStop, bool b1)
{                       
        SetBaseFinance(nContracts, FinanceTake, FinanceStop, b1);
        CreateIndicatorTrade(def_IndicatorTicket0, IT_PRICE, false);
        CreateIndicatorTrade(def_IndicatorTicket0, IT_TAKE, false);
        CreateIndicatorTrade(def_IndicatorTicket0, IT_STOP, false);
}

高亮显示的部分是实际创建 Ticket0 的地方。 此 ticket 可用来根据鼠标和键盘放置挂单：（SHIFT）买入，（CTRL）卖出。 以前，在这一点上创建了等级线，这些等级线用于指示订单的位置。 现在事情简单得多：当我们看到一笔订单时，我们也会看到一笔挂单或一笔持仓。 这意味着我们将始终检查系统。 这就像您要组装一辆汽车，您所有的时间都在检查它的制动器，如此当您真的需要用到它们时，您就会知道它的行为。

冗长代码的最大问题是，当我们创建函数时，我们只能在实际使用时才知道它能否工作。 但现在系统总是在检查 — 即使我们并未调用所有的函数，但因代码在不同的地方重用，故它们也会不断被检查。

我在本文中要提到的最后一个例程如下所示。 它将放置一笔挂单。 请注意，与前几篇文章中的相同函数相比，它变得极致紧凑。

inline void MoveTo(uint Key)
{
        static double local = 0;
        datetime dt;
        bool    bEClick, bKeyBuy, bKeySell, bCheck;
        double  take = 0, stop = 0, price;
                                
        bEClick  = (Key & 0x01) == 0x01;    //Let mouse button click
        bKeyBuy  = (Key & 0x04) == 0x04;    //Pressed SHIFT
        bKeySell = (Key & 0x08) == 0x08;    //Pressed CTRL  
        Mouse.GetPositionDP(dt, price);
        if (bKeyBuy != bKeySell)
        {
                Mouse.Hide();
                bCheck = CheckLimits(price);
        } else Mouse.Show();
        PositionAxlePrice((bKeyBuy != bKeySell ? price : 0), def_IndicatorTicket0, IT_PRICE, (bCheck ? 0 : GetBaseFinanceTakeProfit()), (bCheck ? 0 : GetBaseFinanceStopLoss()), GetBaseFinanceLeveRange(), bKeyBuy);
        if((bEClick) && (bKeyBuy != bKeySell) && (local == 0)) CreateOrderPendent(bKeyBuy, local = price);
        local = (local != price ? 0 : local);
}

原因是，现在系统中会有一个新规则，因此函数“减轻了一些负重”，变得更加紧凑。


结束语

我已在这里介绍了一些将在下一篇文章中用到的变更。 所有这些的目的是令它们更简单，并在不同时间展现出可能不同的事物。 我的想法是，每个人都学习并遵循如何编写 EA，从而帮助您进行操作，这就是为什么我不单只是介绍一个完整并可立即使用的系统。 我想表明，有一些问题需要解决，并介绍我在解决开发过程中出现的问题，和解决问题时所采取的途径。 我希望您能理解这一点。 因为如果打算创建一个系统，并以完备待用的形式呈现，那我最好这样做，并推销这个想法，但这并非我的意图...

本文由MetaQuotes Ltd译自葡萄牙语
原文地址： https://www.mql5.com/pt/articles/10474

附加的文件 |
下载ZIP
EA.zip (12023.87 KB)

注意: MetaQuotes Ltd.将保留所有关于这些材料的权利。全部或部分复制或者转载这些材料将被禁止。

This article was written by a user of the site and reflects their personal views. MetaQuotes Ltd is not responsible for the accuracy of the information presented, nor for any consequences resulting from the use of the solutions, strategies or recommendations described.

该作者的其他文章

最近评论 | 前往讨论 (1)
QQ1171513819 微信AT5050
QQ1171513819 微信AT5050 | 14 9月 2022 在 03:43

       ATFX黄金外汇平台诚招代理商
       ATFX免费开设个人/公司代理，专属代理后台，佣金平仓即返。英国FCA全牌照外汇经纪商诚招代理
     【优势】全球11国12个对外办事处，横跨欧洲、美洲、非洲、亚洲
     【优势】平台稳定，顶级流动性报价。STP模式，多家知名流动商LP报价，快速成交，不卡盘不掉线，不滑点，对冲，拨头皮，秒单，EA等无任何交易限制。
     【优势】英国FCA顶级外汇牌照，塞浦路斯stp牌照。毛里求斯金融牌照，阿布扎比外汇牌照，圣文森特外汇金融牌照等多重监管。资金安全，正规平台支持长期大资金盈利出金。
     【优势】快速安全的多种对公出入金方式：电汇，银联，对公，支付宝，微信等
     【优势】品种全:外汇，黄金，原油，指数，美股，港股等200多种交易品种
     【优势】超低点差黄金0.35，欧美0.18。基础返佣黄金/指数/原油/每手14/15/16美金每手；外汇8/9/10美金每手。MT4操作
        ATFX代理咨询：85292029084（微信）  QQ：1171513819      微信：AT5050
机器学习和交易中的元模型：交易订单的原始时序 机器学习和交易中的元模型：交易订单的原始时序
机器学习中的元模型：很少或无人为干预的情况下自动创建交易系统 — 模型自行决定何时以及如何进行交易。
学习如何基于交易量设计交易系统 学习如何基于交易量设计交易系统
这是我们系列文集中的新篇章，介绍如何基于最流行的技术指标设计交易系统。 本文将专门讨论交易量指标。 作为一个概念，交易量是金融市场交易中非常重要的因素之一，我们必须予以关注。 贯穿本文，我们将学习如何基于交易量指标设计一款简单的系统。
您应该知道的 MQL5 向导技术（第 01 部分）：回归分析 您应该知道的 MQL5 向导技术（第 01 部分）：回归分析
今天的交易者都是一位哲学家，他几乎总是（有意识地或无意识地）寻找新的思路，尝试它们，选择修改或抛弃它们；这是一个需要付出相当勤奋程度的探索过程。 这显然会花费交易者高昂的时间，且需要避免错误。 本系列文章将提出，MQL5 向导应该是交易者的支柱。 为什么呢？ 因为交易者不仅经由 MQL5 向导组装他的新想法来节省时间，而且大大减少了重复编码的错误；他最终会把精力集中在交易哲学的几个关键领域。
神经网络实验（第 1 部分）：重温几何学 神经网络实验（第 1 部分）：重温几何学
在本文中，我将利用实验和非标准方法开发一个可盈利的交易系统，并验证神经网络是否对交易者有任何帮助。