FPsGA Code Modules

Field Programmable soft Gate Array (FPsGA)

edit

Description ⋅ on ESP32 ⋅ Code ⋅

modRandomity

''  modRandomity
''  by Codasaurus Hex 2024.03.1
''  prompted by XenoEngineer@groupKOS.com
'
'    For a laboratory noise study that encompasses a broad range of algorithms,
'    i 'll [sic -xe] define an expanded enumeration in VB6 to cover a variety of
'    pseudorandom number generators (PRNGs), cryptographically secure pseudorandom
'    number generators (CSPRNGs), and other notable algorithms that can be simulated
'    or implemented in a VB6 environment. Given VB6's limitations and the computational
'    complexity of some modern algorithms, the focus will be on those feasible within
'    its capabilities.
'
'    --Codasaurus Hex

Public Enum enumRandomAlgorithm
    enuRA_VB6_Rnd
    enuRA_LCG                         ' Linear Congruential Generator **See note at EOF
    enuRA_MersenneTwister             ' Mersenne Twister, specifically MT19937
    enuRA_Xorshift                    ' A class of shift-register generators
    enuRA_WELL                        ' Well Equidistributed Long-period Linear
    enuRA_BlumBlumShub                ' Cryptographically secure based on hard mathematical problems
    enuRA_ANSI_X9_17                  ' A CSPRNG standard using block ciphers
    enuRA_NIST_SP800_90A_HMAC_DRBG    ' A CSPRNG from NIST using HMAC
    enuRA_NIST_SP800_90A_CTR_DRBG     ' A CSPRNG from NIST using block cipher in counter mode
    enuRA_SimplexNoise                ' Used for procedural content generation, similar to Perlin but computationally more efficient
    enuRA_CellularAutomata            ' For generating randomness through cellular automata rules
    enuRA_LaggedFibonacci             ' A lagged Fibonacci generator
    enuRA_Quantum                     ' Representing quantum random number generators, though not directly implementable in VB6
End Enum

'    Below is the GetAlgorithmParametersTemplate function expanded to include a case for
'    each of the algorithms listed above. Since VB6 cannot directly implement quantum
'    random number generators or certain complex CSPRNGs due to hardware limitations or
'    the need for modern cryptographic libraries, those cases will note the algorithm's
'    typical context or parameters rather than specific implementable details.

Public Function GetAlgorithmParametersTemplate(ByVal algorithm As enumRandomAlgorithm) As String
''  by Codasaurus Hex 2024.03.1
    Select Case algorithm
        Case LCG
            GetAlgorithmParametersTemplate = "Multiplier=a;Increment=c;Modulus=m"
        
        Case MersenneTwister
            GetAlgorithmParametersTemplate = "WordSize=w;DegreeOfRecurrence=n;MiddleWord=m;SeparationPoint=s;TemperingParameterB=b"
        
        Case Xorshift
            GetAlgorithmParametersTemplate = "ShiftValues=[A,B,C]"
        
        Case WELL
            GetAlgorithmParametersTemplate = "StateSize=State;Tap=Tap;Choice=Choice"
        
        Case BlumBlumShub
            GetAlgorithmParametersTemplate = "Prime1=p;Prime2=q;Seed=s"
        
        Case ANSI_X9_17
            GetAlgorithmParametersTemplate = "Key=EncryptionKey;Seed=InitialSeed;Timestamp=CurrentTime"
        
        Case NIST_SP800_90A_HMAC_DRBG
            GetAlgorithmParametersTemplate = "EntropyInput=Entropy;Nonce=Nonce;PersonalizationString=PersonalString"
        
        Case NIST_SP800_90A_CTR_DRBG
            GetAlgorithmParametersTemplate = "EntropyInput=Entropy;Nonce=Nonce;PersonalizationString=PersonalString"
        
        Case SimplexNoise
            GetAlgorithmParametersTemplate = "Gradient=Gradient;Frequency=Freq;Amplitude=Amp;Octaves=Oct;Persistence=Pers"
        
        Case CellularAutomata
            GetAlgorithmParametersTemplate = "RuleSet=RuleNumber;InitialState=State;Iterations=Iter"
        
        Case LaggedFibonacci
            GetAlgorithmParametersTemplate = "J=J;K=K;Modulus=M"
        
        Case Quantum
            GetAlgorithmParametersTemplate = "Note: Quantum RNGs rely on physical phenomena and are not directly implementable in VB6"
        
        Case VB6_Rnd
            GetAlgorithmParametersTemplate = "Seed=Optional seed value for Randomize function"
        
        ' Placeholder for additional algorithms not specifically listed
        Case Else
            GetAlgorithmParametersAsString = "Parameters for this algorithm are not defined."
    End Select
    
    '    Usage:
    '
    '    To use this function, you would call it with the specific algorithm type you're interested in,
    '    and then include the returned pseudocode string in your documentation or header:
    '
    '    Dim algorithmType As enumRandomAlgorithm
    '    algorithmType = LCG ' Example: Selecting the Linear Congruential Generator
    '
    '    Dim pseudocode As String
    '    pseudocode = GetAlgorithmPseudocode(algorithmType)
    '
    '    ' The pseudocode variable now contains the pseudocode for the LCG, ready for inclusion in a header or documentation.
    
    '    This approach provides a structured and extensible way to document the operational logic of various random number
    '    generation algorithms within the constraints of the VB6 environment, aiding in clarity and understanding for
    '    developers and researchers alike.

    '   Explanation:
    '
    '    Each case in the Select Case statement corresponds to an algorithm type from the enumRandomAlgorithm enumeration.
    '    For each algorithm, a string containing the pseudocode is returned. This pseudocode is simplified to capture
    '    the essence of the algorithm's operation without delving into implementation-specific details.
    '    The pseudocode is formatted as a comment block (') that can be included directly in VB6 code or documentation.
    '    It 's written to be understandable at a high level, allowing developers or researchers to grasp the algorithm's
    '    core logic quickly.
    '    This function can be expanded to include additional algorithms by adding more cases to the Select Case statement,
    '    each with its corresponding pseudocode.

End Function

Public Function GetAlgorithmPseudocode(ByVal algorithm As enumRandomAlgorithm) As String
''  by Codasaurus Hex 2024.03.1
    Select Case algorithm
        Case LCG
            GetAlgorithmPseudocode = _
                "' Linear Congruential Generator Pseudocode" & vbCrLf & _
                "state = (a * state + c) mod m"
        
        Case MersenneTwister
            GetAlgorithmPseudocode = _
                "' Mersenne Twister Pseudocode" & vbCrLf & _
                "if index >= n then" & vbCrLf & _
                "    twist()" & vbCrLf & _
                "end if" & vbCrLf & _
                "y = MT[index]" & vbCrLf & _
                "y = y xor ((y >> u) and d)" & vbCrLf & _
                "y = y xor ((y << s) and b)" & vbCrLf & _
                "y = y xor ((y << t) and c)" & vbCrLf & _
                "y = y xor (y >> l)" & vbCrLf & _
                "index = index + 1" & vbCrLf & _
                "return y"
        
        Case Xorshift
            GetAlgorithmPseudocode = _
                "' Xorshift Pseudocode" & vbCrLf & _
                "x ^= x << a" & vbCrLf & _
                "x ^= x >> b" & vbCrLf & _
                "x ^= x << c" & vbCrLf & _
                "return x"
        
        Case WELL
            GetAlgorithmPseudocode = _
                "' WELL (Well Equidistributed Long-period Linear) Pseudocode" & vbCrLf & _
                "state[n] = f(state[n], state[m], ...)" & vbCrLf & _
                "return state[n]"
        
        Case BlumBlumShub
            GetAlgorithmPseudocode = _
                "' Blum Blum Shub Pseudocode" & vbCrLf & _
                "x = x^2 mod n" & vbCrLf & _
                "return x"
        
        Case ANSI_X9_17
            GetAlgorithmPseudocode = _
                "' ANSI X9.17 Pseudocode" & vbCrLf & _
                "timestamp = getCurrentTimestamp()" & vbCrLf & _
                "key = getEncryptionKey()" & vbCrLf & _
                "seed = encrypt(timestamp, key)" & vbCrLf & _
                "output = encrypt(seed xor previousOutput, key)" & vbCrLf & _
                "previousOutput = output" & vbCrLf & _
                "return output"
        
        Case NIST_SP800_90A_HMAC_DRBG
            GetAlgorithmPseudocode = _
                "' NIST SP800-90A HMAC DRBG Pseudocode" & vbCrLf & _
                "V = HMAC(Seed, V)" & vbCrLf & _
                "C = HMAC(Seed, V + 1)" & vbCrLf & _
                "reseed_counter = 1" & vbCrLf & _
                "return HMAC(V, data)"
        
        Case NIST_SP800_90A_CTR_DRBG
            GetAlgorithmPseudocode = _
                "' NIST SP800-90A CTR DRBG Pseudocode" & vbCrLf & _
                "V = AES-CTR(Seed, V)" & vbCrLf & _
                "C = AES-CTR(Seed, V + 1)" & vbCrLf & _
                "reseed_counter = 1" & vbCrLf & _
                "return AES-CTR(V, data)"
        
        Case SimplexNoise
            GetAlgorithmPseudocode = _
                "' Simplex Noise Pseudocode" & vbCrLf & _
                "for each grid point:" & vbCrLf & _
                "    calculate the contribution to the noise" & vbCrLf & _
                "combine contributions for final value"
        
        Case CellularAutomata
            GetAlgorithmPseudocode = _
                "' Cellular Automata Pseudocode" & vbCrLf & _
                "for each cell in grid:" & vbCrLf & _
                "    newState = applyRule(currentState, neighborStates)" & vbCrLf & _
                "update grid with new states"
        
        Case LaggedFibonacci
            GetAlgorithmPseudocode = _
                "' Lagged Fibonacci Pseudocode" & vbCrLf & _
                "x[i] = (x[i-J] op x[i-K]) mod M" & vbCrLf & _
                "where op is an operation (e.g., addition, subtraction)"

        Case Quantum
            GetAlgorithmPseudocode = _
                "' Quantum RNG Pseudocode (Conceptual)" & vbCrLf & _
                "measureQuantumBit()" & vbCrLf & _
                "return bitValue"
        
        ' Adding more algorithms for a broader perspective
        Case Algorithm_PerlinNoise
            GetAlgorithmPseudocode = _
                "' Perlin Noise Pseudocode" & vbCrLf & _
                "for each point in grid:" & vbCrLf & _
                "    find surrounding grid points" & vbCrLf & _
                "    compute gradients" & vbCrLf & _
                "    calculate dot product" & vbCrLf & _
                "    interpolate results" & vbCrLf & _
                "return noise value"
                
        ' Example for a generic hash-based CSPRNG
        Case HashBasedCSPRNG
            GetAlgorithmPseudocode = _
                "' Hash-Based CSPRNG Pseudocode" & vbCrLf & _
                "seed = initialSeed" & vbCrLf & _
                "while more random bits needed:" & vbCrLf & _
                "    seed = hashFunction(seed)" & vbCrLf & _
                "    outputBits = extractBits(seed)" & vbCrLf & _
                "return outputBits"
        Case enuRA_VB6_Rnd
            GetAlgorithmPseudocode = _
                "' VB6 Rnd() Function Pseudocode" & vbCrLf & _
                "' Optionally seed the generator" & vbCrLf & _
                "Randomize [seed]" & vbCrLf & _
                "' Generate a random number between 0 and 1" & vbCrLf & _
                "randomNumber = Rnd()" & vbCrLf & _
                "' To generate a random number in a range" & vbCrLf & _
                "randomInRange = Int((upperBound - lowerBound + 1) * Rnd() + lowerBound)"
                
        ' Placeholder for additional algorithms not specifically listed
        
        Case Else
            GetAlgorithmPseudocode = "Pseudocode for this algorithm is not available."
    End Select
    
    '    Additional Notes
    '    Blum Blum Shub and ANSI X9.17 are presented in a simplified manner, focusing on the core concept.
    '    In practice, these algorithms involve more detailed operations, especially regarding cryptographic
    '    security and proper seed management.
    '    NIST DRBGs (both HMAC and CTR) are summarized to reflect their process of using cryptographic
    '    functions to produce random bits. The actual specifications include detailed state management
    '    and reseeding mechanisms to ensure security.
    '    Simplex Noise, Cellular Automata, and Lagged Fibonacci illustrate basic operations. These algorithms
    '    are more complex in their full implementations, especially when optimized for performance and quality.
    '    The Quantum case is conceptual, as actual quantum random number generation requires physical quantum
    '    phenomena, which cannot be directly simulated in software.
    '    The added Perlin Noise and Hash-Based CSPRNG cases give an idea of how other common algorithms might
    '    be described in pseudocode. These serve as examples of procedural generation and cryptographic
    '    security, respectively.
    '    This expanded function aims to cover a wide range of algorithms, providing a starting point for
    '    researchers and developers to understand and document the operation of various random number
    '    generators within their projects.

End Function



' ========================================================================================
' The VB6 Rnd() function is a type of Pseudorandom Number Generator (PRNG). Specifically,
' it is based on a Linear Congruential Generator (LCG), one of the oldest and simplest
' methods for generating sequences of random numbers. The core principle behind an LCG
' involves using a linear equation to produce a sequence of numbers, where each number in
' the sequence is determined by a linear function of the previous number, modulo a certain
' value. The general form of this equation is:
'
'     X(n+1) = (a * X(n) + c) mod m
'
' where:
'     - X is the sequence of pseudorandom numbers,
'     - a (the multiplier), c (the increment), and m (the modulus) are constants,
'     - n is the index of the current number in the sequence.
'
' The Rnd() function in VB6 generates numbers between 0 and 1 (inclusive of 0 but not 1)
' with a floating-point representation. It can be seeded manually using the Randomize
' statement; if Randomize is not called, VB6 uses a default seed value, which means that
' the same sequence of numbers can be generated each time a program runs, if Randomize is
' not used with a varying seed value.
'
' The nature of Rnd() being an LCG means it inherits the characteristics and limitations of
' LCGs, including:
'
'     - Predictability: With knowledge of the algorithm's parameters and the seed, the
'       sequence of numbers can be predicted.
'     - Periodicity: The sequence will eventually repeat itself.
'     - Quality of Randomness: While suitable for many applications, the randomness generated
'       by LCGs (and therefore Rnd()) may not meet the criteria required for cryptographic
'       purposes or simulations requiring high-quality randomness.
'
' For most casual use cases, like simple simulations, games, or non-security-critical
' applications, Rnd() provides a convenient and sufficient source of randomness. However,
' for applications requiring cryptographically secure random numbers or high-quality
' randomness, other algorithms or external libraries are recommended.
' ========================================================================================