Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C# / VB.NET - [VB.NET] implementazione LCG Random fallito
Forum - C# / VB.NET - [VB.NET] implementazione LCG Random fallito

Avatar
amreo (Normal User)
Pro


Messaggi: 93
Iscritto: 18/03/2013

Segnala al moderatore
Postato alle 14:03
Venerdì, 03/10/2014
  
Codice sorgente - presumibilmente VB.NET

  1. Public Class LCGRandom
  2.         '[Inherits BaseRandom]
  3.  
  4.         Protected Const A As Decimal = 214013
  5.         Protected Const C As Decimal = 2531011
  6.         Protected Const M As Decimal = 2 ^ 32
  7.  
  8.         Protected seed As Decimal
  9.  
  10.         ''' <summary>
  11.         ''' Crea una nuova istanza di LCGRandom
  12.         ''' </summary>
  13.         Public Sub New()
  14.             'crea il seed
  15.             seed = Lowest64Bit(Now.Ticks + Now.ToBinary + Now.TimeOfDay.TotalMilliseconds + Now.TimeOfDay.TotalSeconds)
  16.         End Sub
  17.         ''' <summary>
  18.         ''' Crea una nuova istanza di LCGRandom
  19.         ''' </summary>
  20.         Public Sub New(seed As ULong)
  21.             'imposta il seed
  22.             Me.seed = seed
  23.         End Sub
  24.  
  25.         ''' <summary>
  26.         ''' Scarta un numero pseudo-casuale
  27.         ''' </summary>
  28.         Public Overrides Sub [Next]()
  29.             'ricalcola il seed
  30.             seed = Lowest64Bit((seed * A + C) Mod M)
  31.         End Sub
  32.  
  33.         ''' <summary>
  34.         ''' Genera un byte pseudo-casuale
  35.         ''' </summary>
  36.         ''' <remarks>Il numero pseudo-casuale generato è compreso tra 0 e 255</remarks>
  37.         ''' <returns>Un byte pseudo-casuale</returns>
  38.         Public Overrides Function NextByte() As Byte
  39.             'imposta nextByte
  40.             NextByte = seed Mod 256
  41.             'scarta un numero
  42.             [Next]()
  43.         End Function
  44.         ''' <summary>
  45.         ''' Genera un numero double pseudo-casuale
  46.         ''' </summary>
  47.         ''' <remarks>Il numero pseudo-casuale generato ha un valore compreso tra 0.0 e 1.0</remarks>
  48.         ''' <returns>Un numero double pseudo-casuale</returns>
  49.         Public Overrides Function NextDouble() As Double
  50.             'imposta nextDouble
  51.             NextDouble = seed / M
  52.             'scarta un numero
  53.             [Next]()
  54.         End Function
  55.         ''' <summary>
  56.         ''' Genera un numero intero pseudo-casuale
  57.         ''' </summary>
  58.         ''' <remarks>Il numero generato è compreso tra <see cref="Int32.MinValue">Integer.MinValue</see> e <see cref="Int32.MaxValue">Integer.MaxValue</see></remarks>
  59.         ''' <returns>Un numero intero</returns>
  60.         Public Overloads Overrides Function NextInt() As Integer
  61.             'calcola nextint
  62.             NextInt = seed Mod (UInteger.MaxValue + 1) + Integer.MinValue
  63.             'scarta un numero
  64.             [Next]()
  65.         End Function
  66.         ''' <summary>
  67.         ''' Genera un numero intero pseudo-casuale
  68.         ''' </summary>
  69.         ''' <remarks>
  70.         ''' Il numero generato ha un valore compreso tra
  71.         ''' 0 e <paramref name="maxValue">maxValue</paramref>
  72.         ''' </remarks>
  73.         ''' <param name="maxValue">Massimo valore che il RNG può generare</param>
  74.         ''' <returns>Un numero intero</returns>
  75.         Public Overloads Overrides Function NextInt(maxValue As Integer) As Integer
  76.             'calcola nextint
  77.             NextInt = seed Mod (maxValue + 1)
  78.             'scarta un numero
  79.             [Next]()
  80.         End Function
  81.         ''' <summary>
  82.         ''' Genera un numero intero pseudo-casuale
  83.         ''' </summary>
  84.         ''' <remarks>Il numero intero generato ha un valore compreso tra <paramref name="minValue">minValue</paramref> e <paramref name="maxValue">maxValue</paramref></remarks>
  85.         ''' <param name="minValue">Il numero più piccolo che il RNG può generare</param>
  86.         ''' <param name="maxValue">Il numero più grande che il RNG può generare.</param>
  87.         ''' <returns>Un numero intero pseudo-casuale</returns>
  88.         Public Overloads Overrides Function NextInt(minValue As Integer, maxValue As Integer) As Integer
  89.             'calcola nextint
  90.             NextInt = (seed Mod (maxValue - minValue + 1)) + minValue
  91.             'scarta un numero
  92.             [Next]()
  93.         End Function
  94.         ''' <summary>
  95.         ''' Genera un numero intero pseudo-casuale
  96.         ''' </summary>
  97.         ''' <remarks>Il numero intero generato ha un valore compreso nel <paramref name="rng">range</paramref></remarks>
  98.         ''' <param name="rng">Range in cui è compreso il numero</param>
  99.         ''' <returns>Un numero intero pseudo-casuale</returns>
  100.         Public Overloads Overrides Function NextInt(rng As Range) As Integer
  101.             'calcola nextint
  102.             NextInt = seed Mod (rng.Max + 1) + rng.Min
  103.             'scarta un numero
  104.             [Next]()
  105.         End Function
  106.         ''' <summary>
  107.         ''' Genera un SByte pseudo-casuale
  108.         ''' </summary>
  109.         ''' <remarks>Il numero generato è compreso tra -127 e 128</remarks>
  110.         ''' <returns>Un SByte pseudo-casuale</returns>
  111.         Public Overrides Function NextSByte() As SByte
  112.             'calcola nextint
  113.             NextSByte = seed Mod (Byte.MaxValue + 1) + SByte.MinValue
  114.             'scarta un numero
  115.             [Next]()
  116.         End Function
  117.         ''' <summary>
  118.         ''' Genera un numero single pseudo-casuale
  119.         ''' </summary>
  120.         ''' <remarks>Il numero single generato è compreso tra 0.0 e 1.0</remarks>
  121.         ''' <returns>Un numero single pseudo-casuale</returns>
  122.         Public Overrides Function NextSingle() As Single
  123.             'calcola nextint
  124.             NextSingle = seed / M
  125.             'scarta un numero
  126.             [Next]()
  127.         End Function
  128.         ''' <summary>
  129.         ''' Genera un numero intero pseudo-casuale
  130.         ''' </summary>
  131.         ''' <remarks>Il numero intero ha un valore compreso tra 0 e <see cref="UInt32.MaxValue">UInt32.MaxValue</see></remarks>
  132.         ''' <returns>Un numero intero pseudo-casuale</returns>
  133.         Public Overrides Function NextUInt() As UInteger
  134.             'calcola nextint
  135.             NextUInt = seed Mod (UInteger.MaxValue + 1)
  136.             'scarta un numero
  137.             [Next]()
  138.         End Function
  139.  
  140.         ''' <summary>
  141.         ''' Restituisce il numero decimale solo con i lowest-64bit
  142.         ''' </summary>
  143.         ''' <param name="num">Numero</param>
  144.         ''' <returns>Il numero decimale solo con i lowest-64bit</returns>
  145.         Protected Shared Function Lowest64Bit(ByVal num As Decimal) As Decimal
  146.             'calcola gli interi del numero
  147.             Dim bits() As Integer = Decimal.GetBits(num)
  148.             'restituisce il nuovo decimale
  149.             Return New Decimal(bits(0), bits(1), 0, False, 0)
  150.         End Function
  151.     End Class



Non riesco a capire perchè mi escono sequenze uguali...

PM Quote