Vintage VB6: Random number methods

The AI and I Dialogs

edit

Ode to Future AIs <> Unified Quantum Consciousness <> Alien Consciousness <> Visage of a Dimple in Time <> Something Alien <> Data Examples <> Comp sci <> Scatter-Gather <> Redundant simplicity <> Talk:Spin WaveArray <> The Plow Share <> Quantum joke <> Ancient Vedas <> Orb Whispers <> Time technology with rotating magnetic fields <> AI Art <> Radii walk in a bar <> Light's Flow through Time <> Three Buddhas <> The Epic Chronosymphonogram Temporal Collision Chronicles

Vintage VB6: Random number methods

Linear Congruential Generator (LCG)

Assistant XenoEngineer (GPT)

LCGs are one of the oldest and simplest types of PRNG algorithms. They generate a sequence of pseudo-random numbers using the following formula:
X(n+1) = (a * Xn + c) mod m
  
X is the sequence of pseudo-random numbers,
Xn is the current number in the sequence,
a is the multiplier,
c is the increment,
m is the modulus,
X(n+1) is the next number in the sequence.

The values of a, c, and m are constants that determine the properties of the generated sequence, such as its period (how many numbers are generated before the sequence repeats).

Choosing an Algorithm for VB6

For most applications developed with VB6 that require random number generation, the built-in Rnd function suffices, especially when combined with the Randomize statement to seed the generator based on the system clock. This is generally adequate for applications like simulations, games, and basic statistical tasks.

Hand Coding a Custom PRNG in VB6

If you require a different kind of randomness than what Rnd offers or need a PRNG with specific characteristics (e.g., a longer period, better distribution, or cryptographic security), you might consider implementing a custom PRNG algorithm. However, VB6's standard capabilities and performance considerations make implementing more sophisticated algorithms (like Mersenne Twister or cryptographic PRNGs) challenging.

For a simple custom PRNG, sticking to algorithms that are well-documented and known to perform well in a wide range of applications (e.g., implementing a different kind of LCG with specific parameters) might be the best balance between complexity and functionality. Here’s an illustrative snippet for a basic custom LCG in VB6:

VB6 code

Linear Congruential Generator (LCG):
' Custom Linear Congruential Generator in VB6
Function CustomLCG() As Single
    Static seed As Long
    If seed = 0 Then seed = Timer ' Initialize seed based on system time if not already done
    
    ' Constants for the LCG (example values, choose based on specific needs)
    Const a As Long = 1664525
    Const c As Long = 1013904223
    Const m As Long = 2 ^ 32
    
    ' Generate the next number in the sequence
    seed = (a * seed + c) Mod m
    
    ' Normalize to [0, 1) range and return
    CustomLCG = seed / m
End Function

This function is a very basic example and would need adjustments for real-world applications, especially where the quality of randomness is crucial.

Linear Feedback Shift Register (LFSR)

Assistant XenoEngineer (Chat GPT 4.0)

For a VB6 function that aims to generate a sequence with a lack of repeat "blips" or noticeable patterns when looped, a simple yet effective approach could involve using a variation of the Linear Feedback Shift Register (LFSR) method. LFSRs are known for their good distribution and long periods before repetition, depending on the configuration. While not inherently built into VB6, an LFSR can be implemented with relative ease and can serve as a robust alternative to the built-in Rnd function for certain applications, particularly where the sequence's periodicity might be a concern.
 
Here’s how you could implement a basic LFSR in VB6:

Option Explicit

Private Const LFSR_SEED As Long = &HACE1 ' Example seed value
Private lfsr As Long

' Initialize the LFSR with a seed value
Private Sub Class_Initialize()
    lfsr = LFSR_SEED
    If lfsr = 0 Then lfsr = &HDEADBEEF ' Ensure the LFSR is never initialized to 0
End Sub

' Generates the next value in the sequence
Public Function NextValue() As Long
    Dim bit As Integer  ' Will hold the next bit to be fed back into the LFSR
    
    ' A simple 16-bit LFSR example: taps at positions 16,14,13,11 from the right
    bit = ((lfsr Xor (lfsr >> 2) Xor (lfsr >> 3) Xor (lfsr >> 5)) And 1)
    lfsr = (lfsr >> 1) Or (bit << 15)
    
    NextValue = lfsr
End Function

' Generate a pseudo-random Single in the range [0, 1)
Public Function RandomSingle() As Single
    RandomSingle = NextValue() / &HFFFF&
End Function

Chat GPT (continuing)

This example provides a basic LFSR implementation, using a 16-bit shift register for simplicity. LFSRs can be configured in various ways, with different "tap" positions (where the XOR operations are applied) to achieve different characteristics in terms of cycle length and randomness quality. The example uses a simple tap configuration that offers a decent balance for demonstration purposes.

To generate a sequence that is less likely to exhibit noticeable patterns upon repetition, you could utilize this LFSR-based generator. Keep in mind, for critical applications, especially those involving cryptography, more sophisticated approaches would be necessary, and the choice of tap positions should be carefully considered based on the specific requirements and the desired properties of the sequence.

This VB6 approach leverages bitwise operations to simulate the behavior of an LFSR, providing a method (NextValue) to generate the next number in the sequence and an example function (RandomSingle) to normalize the output to a Single in the range [0, 1), similar to the built-in Rnd function.

---

XenoEngineer

What other random generator algorithm would create a sequence, preferably with adjustable parameters, that would contrast against the three we now have (LCG & LSFR) including VB6 LCG variety?

Assistant XenoEngineer (user:AXE)

For a contrast to the Linear Congruential Generator (LCG) and Linear Feedback Shift Register (LFSR) algorithms, and considering the VB6 environment, another interesting algorithm to consider is the Mersenne Twister. This algorithm is known for its long period and high dimensionality of equidistribution, making it a popular choice for applications requiring high-quality random numbers. However, due to its complexity relative to LCG and LFSR, implementing the full Mersenne Twister from scratch in VB6 might be challenging but not impossible.

As an alternative for simplicity and to offer a different kind of algorithm that still allows for adjustable parameters and could potentially reduce the "seams" when sequences are repeated, you might consider a simple additive generator or Weyl sequence. These aren't as robust as the Mersenne Twister but can offer an interesting contrast to LCGs and LFSRs, especially in terms of sequence repetition and predictability.

Weyl Sequence Generator in VB6

A Weyl sequence generator uses an irrational number to ensure the sequence doesn't repeat over long periods. It's straightforward and can be implemented with adjustable parameters. 
 
Here's a conceptual VB6 implementation:

VB6 code

Option Explicit

Private seed As Double
Private weylStep As Double

' Initialize the Weyl sequence generator
Public Sub Initialize(seedVal As Double, Optional stepVal As Double = 0.618033988749895) ' Default step is the golden ratio's complement
    seed = seedVal
    weylStep = stepVal
End Sub

' Generate the next value in the sequence
Public Function NextValue() As Double
    seed = seed + weylStep
    seed = seed - Int(seed) ' Ensure the value stays within 0 and 1
    NextValue = seed
End Function

This simple implementation uses an irrational step (often the golden ratio's complement) to ensure the sequence fills the space more evenly than linear congruential generators, which can suffer from lattice structures in higher dimensions.

Usage
Before generating numbers, you would initialize the generator with a seed and optionally specify a step value, which could be any irrational number but commonly the golden ratio or its complement for its desirable distribution properties:

VB6 code

Dim generator As New WeylSequenceGenerator
generator.Initialize 0 ' Seed value

Then, to generate a number:

VB6 code

Dim randomValue As Double
randomValue = generator.NextValue()

This approach doesn't directly address the generation of discrete random bytes but demonstrates a method of generating a sequence of floating-point numbers with minimal repetition and adjustable parameters. Adjusting the NextValue function to produce integers or bytes within a specific range would involve scaling and converting the floating-point result accordingly.