摩尔斯电码 - 页 7

新评论
 
另外，如果你有任何想法，哪些统计/指标可能对交易有用，请在这里发表。

只是为了给你一个想法:

1.选定区域内X点的逆转次数
2.相同数量但没有翻转的N*X点的大小
3.体积，至少以刻度表示
 

看一下代码中进行计算的部分会很有趣，只是为了好玩....。

至于想法，我想看看交易量的三角洲所形成的蜡烛。

Karputov和Cybert在这个问题上有一些很好的指标...

  
struct SPoint
{
    double mAsk;
    double mBid;
    double mLow;
    double mHigh;
    double mOpen;
    double mClose;
    double mPoint;
    double mSpread;
    double mVolume;
    datetime mTime;
};

struct SSymbol
{
    string mName;
    double mMean;
    double mUnit;
    double mOrder;
};

struct SSets
{
    SSymbol mSymbol;
    double mAsk[];
    double mBid[];
    double mLow[];
    double mHigh[];
    double mOpen[];
    double mClose[];
    double mPoint[];
    double mSpread[];
    double mVolume[];
    datetime mTime[];
};

struct SName
{
    string mData;
    SSets mSeries[];
};

int getCodes(int length)  // length - parameter that defines required sequence size
{
    SSets iSeries[];
    SName iCombinations[];

    int order = iSets.getPairs(iSeries, InpSymbols);  // split comma-separated string into array of structures iSeries
    int bars = iSets.getSourceSets(iSeries, PERIOD_CURRENT, order, InpDepth, InpShift);  // convert prices from array of structures MqlRates to iSeries

    if (bars < 1)
    {
        return 0;
    }

    int codes[];

    ArrayResize(codes, length);

    for (int k = 0; k < order; k++) // loop over all symbols in iSeries
    {
        ZeroMemory(codes);
        ArrayResize(iCombinations, k + 1);
        iCombinations[k].mData = iSeries[k].mSymbol.mName;
        
        double point = SymbolInfoDouble(iSeries[k].mSymbol.mName, SYMBOL_POINT);

        do
        {
            string comboChain = NULL;

            for (int i = length - 1; i >= 0; i--)
            {
                comboChain = IntegerToString(codes[i]) + comboChain;  // get combination from 000 to 111 on each iteration
            }

            for (int n = bars - 1; n >= length; n--)  // loop over prices for each symbol
            {
                double pips = 0;
                string comboSymbol = NULL;

                for (int i = 0; i < length; i++)  //  comparison of price sequence with generated sequence
                {
                    string symbolUnit = "X"; 
                    double range = iSeries[k].mClose[n - i] - iSeries[k].mOpen[n - i]; 

                    if (range > 0) 
                    {
                        symbolUnit = "1";
                        pips += range;
                    }

                    if (range < 0) 
                    {
                        symbolUnit = "0";
                        pips -= range;
                    }

                    comboSymbol = symbolUnit + comboSymbol;  // real prices define combination 
                }

                if (comboChain == comboSymbol) // compare generated sequence and real sequence
                {
                    int index = -1;
                    int count = ArraySize(iCombinations[k].mSeries);

                    for (int i = 0; i < count; i++)
                    {
                        if (iCombinations[k].mSeries[i].mSymbol.mName == comboChain)
                        {
                            index = i;
                            break;
                        }
                    }

                    if (index < 0)
                    {
                        ArrayResize(iCombinations[k].mSeries, count + 1);
                        ZeroMemory(iCombinations[k].mSeries[count]);
                        index = count;
                    }

                    // count matches, pips, etc

                    iCombinations[k].mSeries[index].mSymbol.mMean++;
                    iCombinations[k].mSeries[index].mSymbol.mOrder += iCombinations[k].mSeries[index].mSymbol.mMean + n;
                    iCombinations[k].mSeries[index].mSymbol.mUnit += MathAbs(pips / point);
                    iCombinations[k].mSeries[index].mSymbol.mName = comboChain;
                }
            }

        } while (iHelpers.getChain(codes, length)); // generate possible combinations from 000 to 111
    }

    string res = "\n";

    for (int k = 0; k < order; k++)
    {
        int count = ArraySize(iCombinations[k].mSeries);

        res += iCombinations[k].mData + "\n";

        for (int n = 0; n < count; n++)
        {
            res += 
                iCombinations[k].mSeries[n].mSymbol.mName + " : " + 
                DoubleToString(iCombinations[k].mSeries[n].mSymbol.mMean, 1) + " : " + 
                DoubleToString(iCombinations[k].mSeries[n].mSymbol.mOrder, 1) + " : " + 
                DoubleToString(iCombinations[k].mSeries[n].mSymbol.mUnit, 1) + "\n";
        }
    }

    iHelpers.debug(res); // print to a file

    return 1;
}
该代码很繁琐，因为系列的大小可以在参数中设置，也可以设置所有配对的集合，用逗号分开。
 

一个好的和迷人的想法。

至少它证明了市场不适合通过蜡烛图分析来分析。

市场是对真正的交易者的行动的反应。

如果在某一时刻有100个交易者--能有多少种零和一的组合？

 
Renat Akhtyamov: 如果在一个特定的时间有100个交易者--能有多少种零和一的组合？
交易员的数量与时间-价格图表有什么关系？
 
Andy Sanders:
交易数量与时间价格图的关系如何？

烛台的形成取决于--有多少人卖出，有多少人买入。

就是说，烛台的顺序和形状是随机的。烛台序列有大量的组合。

试图寻找和分析模式是乌托邦。

在这里，举例来说。
 

Renat Akhtyamov:

..烛台序列的组合是巨大的。
试图寻找和分析模式的做法是乌托邦。

蜡烛图分析（毕竟是乌托邦）不应该与模式计算相混淆。

烛台本身就是乌托邦--对烛台时期内变化性质的粗略表述。

而这种模式不是建立在蜡烛图上，而是建立在报价序列上。该模式与条形开盘时间 无关，它可以是随机长度，也可以是基于平均数据等。非随机模式几乎是 "普通 "交易者的唯一可能性，对其本质的理解是进入 "赚钱者俱乐部 "的最低水平。

 
User_mt5:

蜡烛图分析（毕竟是乌托邦）不应该与模式计算相混淆。

烛台本身已经是乌托邦了--粗略地表示了烛台时期内变化的性质。

而这种模式不是建立在蜡烛图上，而是建立在报价序列上。该模式与条形图的开放时间 无关，它可能是随机的长度，它可能建立在平均的数据上等等。非随机模式 几乎是 "普通 "交易者的唯一可能性，对其本质的理解是进入 "赚钱者俱乐部"的最低水平。

哇。好吧。

好运!

PS。

既然一切都那么酷，我们应该另外定义烛台的比例，其大小的最大和最小，以便找到模式。

因此，代码0,1,1，将变成这样的东西。10,30,33

每个模式都必须通过历史运行，以设置有利可图的参数。

然后创建一个模式数据库

这是一项伟大的工作，可能会带来一个积极的结果。

 
Renat Akhtyamov:

哇。好的，好的。

好运!

PS。

既然这么酷，我们需要进一步定义蜡烛的比例，高点和低点以及它们的大小，以便找到模式。

因此，代码0,1,1，将变成这样的东西。10,30,33

不，即使是猫也不可能在两圈、三圈内出生。

但在原则上...原则上，你可以做摩斯密码，但要注意：如果你对最终结果不感兴趣。

 
Renat Akhtyamov:

每个模式都必须通过历史运行，以设置有利可图的参数。

然后创建一个模式数据库

这是一项巨大的工作，以后可能会带来积极的结果。

这一点是可以认同的。只是在这些术语中--"可能 "和 "随后"。

甚至在这之前，你必须定义这个非常 "每一个模式"。而且，这并不有利可图。这个方法不是关于利润和一般的交易。这是关于重复类似的模式。即右边的图案与他们左边的相似。其长度、形状、振幅、周期性频率和其他参数都有待研究。

是的，如果你在烛台的基础上做同样的事，你会有同样的结果，但会更弱，更笨拙。而且形态较少--仅仅是根据蜡烛图的定义。

12345678910
新评论