Método de congruencia aditiva para generar números pseudoaleatorios

El método congruente aditivo es un tipo de generador congruente lineal para generar números pseudoaleatorios en un rango específico. Este método se puede definir como: 

dónde,  

X , la secuencia de números pseudoaleatorios
m ( > 0), el módulo
c [0, m), el incremento
X ₀ [0, m), el valor inicial de la secuencia, denominado semilla

m, c, X ₀ debe elegirse apropiadamente para obtener un período casi igual a m.

Acercarse: 

• Elija el valor inicial X ₀ , el parámetro de módulo m y el término de incremento c.
• Inicialice la cantidad requerida de números aleatorios para generar (por ejemplo, una variable entera noOfRandomNums ).
• Defina el almacenamiento para mantener los números aleatorios generados (aquí, se considera el vector ) de tamaño noOfRandomNums .
• Inicialice el índice 0 del vector con el valor inicial ^.
• Para el resto de los índices, siga el método congruencial aditivo para generar los números aleatorios.

númerosaleatorios[i] = (númerosaleatorios[i – 1] + c) % m 

Finalmente, devuelva los números aleatorios generados.

A continuación se muestra la implementación del enfoque anterior:  

// C++ implementation of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to generate random numbers
void additiveCongruentialMethod(
    int Xo, int m, int c,
    vector<int>& randomNums,
    int noOfRandomNums)
{
 
    // Initialize the seed state
    randomNums[0] = Xo;
 
    // Traverse to generate required
    // numbers of random numbers
    for (int i = 1; i < noOfRandomNums; i++) {
 
        // Follow the additive
        // congruential method
        randomNums[i]
            = (randomNums[i - 1] + c)
              % m;
    }
}
 
// Driver Code
int main()
{
    int Xo = 3; // seed value
    int m = 15; // modulus parameter
    int c = 2; // increment term
 
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 20;
 
    // To store random numbers
    vector<int> randomNums(noOfRandomNums);
 
    // Function Call
    additiveCongruentialMethod(
Xo, m, c,
                               randomNums,
 noOfRandomNums);
 
    // Print the generated random numbers
    for (int i = 0; i < noOfRandomNums; i++) {
        cout << randomNums[i] << " ";
    }
 
    return 0;
}

// Java implementation of the
// above approach
class GFG{
 
// Function to generate random numbers
static void additiveCongruentialMethod(
    int Xo, int m, int c,
    int []randomNums,
    int noOfRandomNums)
{
 
    // Initialize the seed state
    randomNums[0] = Xo;
 
    // Traverse to generate required
    // numbers of random numbers
    for(int i = 1; i < noOfRandomNums; i++)
    {
 
        // Follow the additive
        // congruential method
        randomNums[i] = (randomNums[i - 1] + c) % m;
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Seed value
    int Xo = 3;
     
    // Modulus parameter
    int m = 15;
     
    // Increment term
    int c = 2;
 
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 20;
 
    // To store random numbers
    int []randomNums = new int[noOfRandomNums];
 
    // Function Call
    additiveCongruentialMethod(Xo, m, c,
                               randomNums,
                               noOfRandomNums);
 
    // Print the generated random numbers
    for(int i = 0; i < noOfRandomNums; i++)
    {
        System.out.print(randomNums[i] + " ");
    }
}
}
 
// This code is contributed by PrinciRaj1992

# Python3 implementation of the
# above approach
 
# Function to generate random numbers
def additiveCongruentialMethod(Xo, m, c,
                               randomNums,
                               noOfRandomNums):
 
    # Initialize the seed state
    randomNums[0] = Xo
 
    # Traverse to generate required
    # numbers of random numbers
    for i in range(1, noOfRandomNums):
         
        # Follow the linear congruential method
        randomNums[i] = (randomNums[i - 1] + c) % m
 
# Driver Code
if __name__ == '__main__':
     
    # Seed value
    Xo = 3
     
    # Modulus parameter
    m = 15
     
    # Multiplier term
    c = 2
 
    # Number of Random numbers
    # to be generated
    noOfRandomNums = 20
 
    # To store random numbers
    randomNums=[0] * (noOfRandomNums)
 
    # Function Call
    additiveCongruentialMethod(Xo, m, c,
                               randomNums,
                               noOfRandomNums)
 
    # Print the generated random numbers
    for i in randomNums:
        print(i, end = " ")
 
# This code is contributed by mohit kumar 29

// C# implementation of the
// above approach
using System;
 
class GFG{
 
// Function to generate random numbers
static void additiveCongruentialMethod(
    int Xo, int m, int c,
    int []randomNums,
    int noOfRandomNums)
{
 
    // Initialize the seed state
    randomNums[0] = Xo;
 
    // Traverse to generate required
    // numbers of random numbers
    for(int i = 1; i < noOfRandomNums; i++)
    {
 
        // Follow the additive
        // congruential method
        randomNums[i] = (randomNums[i - 1] + c) % m;
    }
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Seed value
    int Xo = 3;
     
    // Modulus parameter
    int m = 15;
     
    // Increment term
    int c = 2;
 
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 20;
 
    // To store random numbers
    int []randomNums = new int[noOfRandomNums];
 
    // Function call
    additiveCongruentialMethod(Xo, m, c,
                               randomNums,
                               noOfRandomNums);
 
    // Print the generated random numbers
    for(int i = 0; i < noOfRandomNums; i++)
    {
        Console.Write(randomNums[i] + " ");
    }
}
}
 
// This code is contributed by PrinciRaj1992

<script>
 
// Javascript program to implement
// the above approach
 
// Function to generate random numbers
function additiveCongruentialMethod(
    Xo, m, c,
    randomNums, noOfRandomNums)
{
   
    // Initialize the seed state
    randomNums[0] = Xo;
   
    // Traverse to generate required
    // numbers of random numbers
    for(let i = 1; i < noOfRandomNums; i++)
    {
   
        // Follow the additive
        // congruential method
        randomNums[i] = (randomNums[i - 1] + c) % m;
    }
}
   
    // Driver Code
           
    // Seed value
    let Xo = 3;
       
    // Modulus parameter
    let m = 15;
       
    // Increment term
    let c = 2;
   
    // Number of Random numbers
    // to be generated
    let noOfRandomNums = 20;
   
    // To store random numbers
    let randomNums = new Array(noOfRandomNums).fill(0);
   
    // Function Call
    additiveCongruentialMethod(Xo, m, c,
                               randomNums,
                               noOfRandomNums);
   
    // Print the generated random numbers
    for(let i = 0; i < noOfRandomNums; i++)
    {
        document.write(randomNums[i] + " ");
    }
 
</script>

3 5 7 9 11 13 0 2 4 6 8 10 12 14 1 3 5 7 9 11

El significado literal de pseudo es falso . Estos números aleatorios se llaman pseudo porque se utiliza algún procedimiento aritmético conocido para generar. Incluso la secuencia generada forma un patrón, por lo que el número generado parece ser aleatorio, pero puede que no sea verdaderamente aleatorio .