关于SI语言的问题 - 页 11

新评论
 
TheXpert:

指向一块大小为4或8字节的数据的指针。

如果你使用类似pragma pack 1的东西，大小将是一样的（可能是1个字节）。

我有时也会在VS C++中，在asm列表模式下进行编译，然后再看，很多东西都变得清晰了。是的，这听起来很可怕，但asm是最后手段中的绝对真理。而且语言并不难懂。很难写得正确））。

  
Это рекурсия просто. Быстрая сортировка как раз таки и применяет рекурсивный вызов функции. О принципах, преимуществах и недостатках ее использования можете почитать в интернете. И да, это применительно к любому ЯП. В кратце скажу, что главное требование рекурсии - это то, что бы последующий вызов рекурсии приближал алгоритм к завершению. Ну и главный недостаток это требование к оперативной памяти при большое обработке данных, так как каждый вызов такой рекурсии будет блокировать память.... Простой пример с рекурсией на том же си и нахождению факториала в 2 вариациях. 
1) Рекурсия внутри 1 функции:

long long Factorial(int n){
        if(n == 1) return 1;
        return n * Factorial(n-1); // Здесь выполнил требование приближение рекурсии к завершению(то есть n стремится к 1(где исполнится условие выше))
}

2) Рекурсия между несколькими функциями:

int Fun2(int); // Прототип.
int Fun1(int i){
        if(i == -5){return i;}
        return i + Fun2(i-1);
}

int Fun2(int i){
        if(i == -5){return i;}
        return i + Fun1(i-1);
}
 
Gleb Krel:

是的，谢谢你......正如他们所说，我知道但忘记了，因为我不是一个程序员，很少做这个:)

 

我想把这个源代码移植到MQL，但我不确定是否能处理std::deque。

#include <deque>

class net
{   std::deque<float*> w;    // весовые коэффициенты (== это образцам)
    const unsigned     n;    // количество входов сети
    
    float activation(float v) const
    {   return v>n?n:v<0?0:v;
    }
public:
    net(unsigned numInputs):n(numInputs){}
    ~net(void)
    {   for(unsigned i(0); i<w.size();) delete [] w[i++];
    }
    unsigned learnImage(const float* const image)
    {   w.push_back( (float*)memcpy( new float[n],image, sizeof(float)*n) );
        return w.size();
    }
    unsigned recognizeImage(const float* const image) const
    {   float*  axons( (float*)memset(new float[w.size()],0,sizeof(float)*w.size()) );
        float   sum1(.0), sum2(.0), e(0.95 f/w.size());
        unsigned i,j;

        for(i=0; i < w.size(); ++i)    // цикл инициализации сети
        {   for(j=0; j < n; ++j)
                axons[i] += image[j]*w[i][j];
            sum1 += axons[i] = activation(0.5 f*(axons[i]+float(n) ) );
        }
                
        while( sum2 != sum1 )        // цикл пока выходы сети изменяются
        {   sum1 = 0.0 f * ( sum2 = sum1 );
            for(i=0; i < w.size(); ++i)
                sum1 += axons[i] = activation( axons[i]-e*(sum2-axons[i]) );
        }
        for(i=w.size(); i!=-1 u && !axons[i--];);    // поиск активного аксона сети 
        delete [] axons;
        return i;
    }


};



int _tmain(int argc, _TCHAR* argv[])
{  // входы можно сделать и целочисленными, роли играть не будет
    float a1[4][15] = {{1.,1.,1.,  1.,-1.,-1.,  1.,-1.,-1.,  1.,-1.,-1.,  1.,1.,1.},// символ С
                        {1.,1.,1.,  1.,-1.,-1.,  1.,1.,-1.,   1.,-1.,-1.,  1.,1.,1.}, // Символ E
                        {1.,1.,1.,  1.,-1.,1.,   1.,-1.,1.,   1.,-1.,1.,   1.,1.,1.}, // Символ О
                        {1.,1.,1.,  1.,-1.,1.,   1.,-1.,1.,   1.,-1.,1.,   1.,1.,1.}  // искаженный
                      };

    net n(15);
    n.learnImage( a1[0] );
    n.learnImage( a1[1] );    
    n.learnImage( a1[2] );
    return n.recognizeImage( a1[3] );
}

摘自这里:https://habr.com/ru/sandbox/43916/

SZZY：在谷歌上搜索，没有找到任何其他汉明的源代码，欢迎提供其他来源的链接（不是霍普菲尔德网络！！！--谷歌总是把它们放在一起给出）。

 
Igor Makanu:

我想把这个源代码移植到MQL，但我不确定是否能处理std::deque。

这是一个双向的列表。上面的代码只有push_back，所以有可能你可以用一个向量来代替它。

如果没有，你可以通过数组做一个简单的deque的实现，在STL中它是以某种方式实现的。

 
Andrei Trukhanovich:

这是一个双向的列表。在上面的代码中，只有push_back，所以有可能被一个向量所取代。

如果没有，你可以通过数组做一个简单的deque的实现，有开始和结束的冗余。

我在谷歌上搜索了std::deque，它就像你写的那样，但是...我不知道如何使用它，只是用一个矢量来代替它...总的来说，这个例子是一个教程，我不想把它搞乱，并确定它的工作方式是错误的))))。

ZS：在F#中也有一个例子--但我认为它太多了；)

[删除]  
Igor Makanu:

我想把这个源代码移植到MQL，但我不确定是否能处理std::Alert( n.recognitionImage( a1_3 ) )。

摘自这里:https://habr.com/ru/sandbox/43916/

HZZ：在谷歌上搜索，我没有找到关于飞行的其他汉明网络来源，也欢迎链接到其他来源（它不是净的霍普菲尔德！！！--谷歌总是把它们放在一起给出。）

Igor，我不认为写一个deque是合理的，在绝大多数情况下，一个向量就足够了。我重写了你的例子，使用了关于stl的主题中的一个矢量。

#include <myincl/1_mystd.mqh>

template <typename T>
void fill_vector_from_array(vector_fund<T> &dest, const T &src[]) {
   dest.clear();
   for (int i = 0;  i < ArraySize(src);  ++ i)
      dest.push_back(src[i]);
}
template <typename T>
void fill_vector(vector_fund<T> &dest, T val) {
   for (uint i = 0;  i < dest.size();  ++ i)
      dest.a[i] = val;
}

class net
{   vector_ref<vector_fund<float>> w;    // весовые коэффициенты (== это образцам)
    const uint n;                        // количество входов сети
    
    float activation(float v) const {
        return v>n?n:v<0?0:v;
    }
public:
    net(unsigned numInputs):n(numInputs){}
    unsigned learnImage(const float &image[]) {
        vector_fund<float> tmp;
        fill_vector_from_array(tmp, image);
        w.push_back(tmp);
        return w.size();
    }
    unsigned recognizeImage(const float &image[]) const {   
        vector_fund<float> axons(this.w.size());
        fill_vector<float>(axons, 0);
    
        float   sum1=.0, sum2=.0, e=0.95 f/w.size();
        unsigned i,j;
        vector_fund<float> image_vec;
        fill_vector_from_array(image_vec, image);
        
        for(i=0; i < w.size(); ++i) {   // цикл инициализации сети
            for(j=0; j < n; ++j)
                axons.a[i] += image_vec.a[j]*w.a[i].a[j];
            sum1 += axons.a[i] = activation(0.5 f*(axons.a[i]+float(n) ) );
        }
                
        while( sum2 != sum1 ) {       // цикл пока выходы сети изменяются
            sum1 = 0.0 f * ( sum2 = sum1 );
            for(i=0; i < w.size(); ++i)
                sum1 += axons.a[i] = activation( axons.a[i]-e*(sum2-axons.a[i]) );
        }
        for(i=w.size()-1; i!=(uint)-1 && !axons.a[i--];);    // поиск активного аксона сети 
        return i;
    }


};

unsigned fn() {
   // создал несколько массивов, отказывается мкл передавать многомерные массивы.
   float a1_0[15] = {1.,1.,1.,  1.,-1.,-1.,  1.,-1.,-1.,  1.,-1.,-1.,  1.,1.,1.}; // символ С
   float a1_1[15] = {1.,1.,1.,  1.,-1.,-1.,  1.,1.,-1.,   1.,-1.,-1.,  1.,1.,1.}; // Символ E
   float a1_2[15] = {1.,1.,1.,  1.,-1.,1.,   1.,-1.,1.,   1.,-1.,1.,   1.,1.,1.}; // Символ О
   float a1_3[15] = {1.,1.,1.,  1.,-1.,1.,   1.,-1.,1.,   1.,-1.,1.,   1.,1.,1.}; // искаженный

    net n(15);
    n.learnImage( a1_0 );
    n.learnImage( a1_1 );    
    n.learnImage( a1_2 );

    return n.recognizeImage( a1_3 );
}

void OnStart()
{
   Alert( fn() );
}

我不想搞砸，并确定它应该工作不正常))))。

为了检查这一点，我测试了源代码和µl代码

    Alert( n.recognizeImage( a1_0 ) );
    Alert( n.recognizeImage( a1_1 ) );
    Alert( n.recognizeImage( a1_2 ) );
    Alert( n.recognizeImage( a1_3 ) );

在这两种情况下都得到：1 1 0 4294967295

HH：顺便说一下，来源中似乎有一个错误--超出了数组边界（该同志忘了加-1）。

for(i=w.size()-1; i!=-1 u && !axons[i--];);    // поиск активного аксона сети
 
Vict:

Igor，我不认为写一个deque是合理的，在绝大多数情况下，一个向量就足够了。我从关于stl的主题中用矢量重写了你的例子。

为了检查它，我在pluses源码和µl代码上运行，例如

在这两种情况下都得到：1 1 0 4294967295

HH：顺便说一下，在源代码中似乎有一个错误--数组超限（该同志忘了加-1）。

О!太快了!谢谢HUMAN！！！。

1...4567891011
新评论