FórumSeções

Como é que MathRand() gera valores? - página 2

Novo comentário
yu-sha:

Por favor, diga-me como MathRand() obtém valores.

Podemos esperar que MathRand() seja distribuído de forma uniforme no intervalo declarado?

aqui está um exemplo, é claro que há outros algoritmos mais complexos...

fonte rand.c :

/***
*rand.c - random number generator
*
*       Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*       defines rand(), srand() - random number generator
*
*******************************************************************************/

#include <cruntime.h>
#include <mtdll.h>
#include <stddef.h>
#include <stdlib.h>

#ifndef _MT
static long holdrand = 1 L;
#endif  /* _MT */

/***
*void srand(seed) - seed the random number generator
*
*Purpose:
*       Seeds the random number generator with the int given.  Adapted from the
*       BASIC random number generator.
*
*Entry:
*       unsigned seed - seed to seed rand # generator with
*
*Exit:
*       None.
*
*Exceptions:
*
*******************************************************************************/

void __cdecl srand (
       unsigned int seed
       )
{
#ifdef _MT

       _getptd()->_holdrand = (unsigned long)seed;

#else  /* _MT */
       holdrand = (long)seed;
#endif  /* _MT */
}


/***
*int rand() - returns a random number
*
*Purpose:
*       returns a pseudo-random number 0 through 32767.
*
*Entry:
*       None.
*
*Exit:
*       Returns a pseudo-random number 0 through 32767.
*
*Exceptions:
*
*******************************************************************************/

int __cdecl rand (
       void
       )
{
#ifdef _MT

       _ptiddata ptd = _getptd();

       return( ((ptd->_holdrand = ptd->_holdrand * 214013 L
           + 2531011 L) >> 16) & 0x7fff );

#else  /* _MT */
       return(((holdrand = holdrand * 214013 L + 2531011 L) >> 16) & 0x7fff);
#endif  /* _MT */
}

É necessária uma função RNG com o número Int de 0 a qualquer valor.

Uma vez que o valor máximo de Int =2.147.483.647, calculamos até este valor.

Obtivemos esta função. Penso que a distribuição é uniforme.

int RandomInteger(int max_vl){//случайное Int от 0 до  Max Int
        //srand(0);//если нужна повторяемость.  MathSrand(GetTickCount()) если нужна неповторяемость
        int r=MathRand();// от 0 до 32767.
        double k=32767.0;
        if(max_vl>32767){
                r=r+MathRand()*32767;//0...32767 + 0.. 32767*32767(с шагом 32767)  max=1073709056 > 1 mlrd
                k=k*k;
                if(max_vl>1073709056){// int type max alue =2 147 483 647 > 2 mlrd
                        r=r*2+MathRand()%2;//0...2 147 483 647 > to max int number c шагом 2 + (0 или 1)
                        k=k*2;
                }
        }
        return (int)MathFloor(r/k*max_vl);
}
O artigo tem um gerador para 4294967295
Rorschach:
O artigo tem um gerador até 4294967295

Alglib SB tem um oscilador de alta precisão

UPD: tenteihttps://www.mql5.com/ru/forum/324066#comment_13500222 , parece funcionar, mas não há documentação para Alglib em MQL5, deve lê-la no site de Alglib

Rorschach:
O artigo tem um gerador para 4294967295

Obrigado, comparei-o em termos de velocidade computacional.
A minha função em rand() padrão acabou por ser 2 vezes mais lenta. Embora o código parecesse muito mais simples.


Igor Makanu:

Existe um gerador de alta precisão em Alglib

UPD: tenteihttps://www.mql5.com/ru/forum/324066#comment_13500222 , parece funcionar, mas não há documentação para Alglib em MQL5, deve lê-la no site de Alglib

Eu vi-o mas quero-o sem algibeira. Além disso, essa função tem uma grande quantidade de */%. Não comparei a sua velocidade, uma vez que é obviamente mais lenta. O gerador do artigo funciona com turnos de bits - é mais rápido.

Reescrevi a minha função para optimizar a velocidade: 

int RandomInteger(int max_vl){return (int)MathFloor((MathRand()+MathRand()*32767.0)/1073741824.0*max_vl);}//случайное Int от 0 до  Max Int
A distribuição acabou por se revelar uniforme. Ver imagens da experiência no blogue https://www.mql5.com/ru/blogs/post/735953

Eu reescrevi o RNG a partir do artigo.
Eu descartei coisas desnecessárias, e foi isto que recebi:

//если из define переместить в код RNDUint, то скорость работы увеличится на 30% для 10 млн повторов с 600 мс до 850 мс
#define  xor32  xx=xx^(xx<<13);xx=xx^(xx>>17);xx=xx^(xx<<5)
#define  xor128 t=(x^(x<<11));x=y;y=z;z=w;w=(w^(w>>19))^(t^(t>>8))
#define  inidat x=123456789;y=362436069;z=521288629;w=88675123;xx=2463534242

class RNDUint{
protected:
   uint      x,y,z,w,xx,t;
public:
        RNDUint(void){inidat;};
        ~RNDUint(void){};
   uint      Rand()    {xor128;return(w);};//равномерное распределение на отрезке [0,UINT_MAX=4294967295].
   double    Rand_01() {xor128;return((double)w/UINT_MAX);};//равномерное распределение на отрезке [0,1].
   void      Reset()   {inidat;};//сброс всех исходных значений в первоначальное состояние.
   void      SRand(uint seed)  {//установка новых исходных значений генератора.seed= [0,UINT_MAX=4294967295]. При seed=0 функция меняет начальные значения случайным образом.
      int i;if(seed!=0){xx=seed;}for(i=0;i<16;i++){xor32;}xor32;x=xx;xor32;y=xx;xor32;z=xx;xor32;w=xx;for(i=0;i<16;i++){xor128;}
   };
};

A distribuição acabou também por ser uniforme.

Eu comparei a velocidade de ambas as funções, original do artigo e simples MathRand():


O original do artigo rnd.Rand_01() - 602 ms.
Encurtado de acordo com o artigo rnu.Rand_01() - 596 ms
A minha versão optimizada de RandomInteger() - 840 ms (versão antiga 1200 ms, i.e. 25% mais rápida)
Apenas por MathRand() - 353 ms (mais rápido, mas a distribuição será desigual. Se a gama de números necessários for superior a 32767, o resultado será ignorado. Se menos de 32767, por exemplo i=31111. então os arredondamentos serão mais frequentes para alguns pontos).

Tirar partido)
Rand 0 ... Max Int с равномерным распределением
Rand 0 ... Max Int с равномерным распределением
  • www.mql5.com
Потребовалась функция ГСЧ с гнерацией числа Int от 0 до любого значения.Получилась такая функция. Думаю распределение получилось равномерным. int RandomInteger(int max_vl){return
elibrarius:
Interessante. Encontrei outro aleatório na biblioteca padrão, mas é pouco provável que seja melhor.

Porquê complicar tanto as coisas?

Pode fazê-lo desta forma (mais ou menos falando):

if (MathRand()%100>50) => Buy

if (MathRand()%100<50) => Sell

E se quiseres brincar ou ver o que ele mostra, podes fazê-lo:

int x=1;

if (MathRand()%100>50) x=1;

if (MathRand()%100<50) x=2;

Comment(x);

e ver como muda os valores.

elibrarius:

Reescrevi a minha função para optimizar a velocidade:

A distribuição é uniforme. Ver imagens da experiência no blogue https://www.mql5.com/ru/blogs/post/735953

Eu reescrevi o RNG a partir do artigo.
Eu descartei coisas desnecessárias e foi isso que recebi:

A distribuição acaba também por ser uniforme.

Comparei-a com a distribuição da ajuda, não vejo qualquer diferença

Arquivos anexados:
UniformDistribution_User.mq5  14 kb
1234
Novo comentário