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

El método de congruencia lineal es una clase de algoritmos generadores de números pseudoaleatorios (PRNG) que se utilizan para generar secuencias de números aleatorios en un rango específico. Este método se puede definir como: 

dónde,

X, es la secuencia de números pseudoaleatorios
m, ( > 0) el módulo
a, (0, m) el multiplicador
c, (0, m) el incremento
X _{0 ,}  [0, m) – Valor inicial de la secuencia conocida como semilla

m, a, c y X ₀ deben elegirse adecuadamente para obtener un período casi igual a m. 

Para a = 1, será el método de la congruencia aditiva.
Para c = 0, será el método de la congruencia multiplicativa. 

Acercarse: 

• Elija el valor inicial X _0, el parámetro de módulo m, el término multiplicador a y el término de incremento c.
• Inicialice la cantidad requerida de números aleatorios para generar (por ejemplo, una variable entera noOfRandomNums ).
• Defina un 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 de congruencia lineal para generar los números aleatorios.

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

Finalmente, devuelva los números aleatorios.

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 linearCongruentialMethod(
    int Xo, int m, int a, 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 linear congruential method
        randomNums[i]
            = ((randomNums[i - 1] * a) + c) % m;
    }
}
 
// Driver Code
int main()
{
    int Xo = 5; // Seed value
    int m = 7; // Modulus parameter
    int a = 3; // Multiplier term
    int c = 3; // Increment term
 
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 10;
 
    // To store random numbers
    vector<int> randomNums(
        noOfRandomNums);
 
    // Function Call
    linearCongruentialMethod(
        Xo, m, a, 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
import java.util.*;
 
class GFG{
 
// Function to generate random numbers
static void linearCongruentialMethod(int Xo, int m,
                                     int a, 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 linear congruential method
        randomNums[i] = ((randomNums[i - 1] * a) + c) % m;
    }
}
 
// Driver code
public static void main(String[] args)
{
     
    // Seed value
    int Xo = 5;
     
    // Modulus parameter
    int m = 7;
     
    // Multiplier term
    int a = 3;
     
    // Increment term
    int c = 3;
     
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 10;
     
    // To store random numbers
    int[] randomNums = new int[noOfRandomNums];
     
    // Function Call
    linearCongruentialMethod(Xo, m, a, 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 offbeat

# Python3 implementation of the
# above approach
 
# Function to generate random numbers
def linearCongruentialMethod(Xo, m, a, 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] * a) +
                                         c) % m
 
# Driver Code
if __name__ == '__main__':
     
    # Seed value
    Xo = 5
     
    # Modulus parameter
    m = 7
     
    # Multiplier term
    a = 3
     
    # Increment term
    c = 3
 
    # Number of Random numbers
    # to be generated
    noOfRandomNums = 10
 
    # To store random numbers
    randomNums = [0] * (noOfRandomNums)
 
    # Function Call
    linearCongruentialMethod(Xo, m, a, 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 linearCongruentialMethod(int Xo, int m,
                                     int a, 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 linear congruential method
        randomNums[i] = ((randomNums[i - 1] * a) + c) % m;
    }
}
 
// Driver code
public static void Main(String[] args)
{
     
    // Seed value
    int Xo = 5;
     
    // Modulus parameter
    int m = 7;
     
    // Multiplier term
    int a = 3;
     
    // Increment term
    int c = 3;
     
    // Number of Random numbers
    // to be generated
    int noOfRandomNums = 10;
     
    // To store random numbers
    int[] randomNums = new int[noOfRandomNums];
     
    // Function call
    linearCongruentialMethod(Xo, m, a, c,
                             randomNums,
                             noOfRandomNums);
     
    // Print the generated random numbers
    for(int i = 0; i < noOfRandomNums; i++)
    {
        Console.Write(randomNums[i] + " ");
    }
}
}
 
// This code is contributed by sapnasingh4991

<script>
 
// Javascript program to implement
// the above approach
 
// Function to generate random numbers
function linearCongruentialMethod(Xo, m,  a, 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 linear congruential method
        randomNums[i] = ((randomNums[i - 1] * a) + c) % m;
    }
}
 
    // Driver Code
         
        // Seed value
    let Xo = 5;
       
    // Modulus parameter
    let m = 7;
       
    // Multiplier term
    let a = 3;
       
    // Increment term
    let c = 3;
       
    // Number of Random numbers
    // to be generated
    let noOfRandomNums = 10;
       
    // To store random numbers
    let randomNums = new Array(noOfRandomNums).fill(0);
       
    // Function Call
    linearCongruentialMethod(Xo, m, a, c,
                             randomNums,
                             noOfRandomNums);
       
    // Print the generated random numbers
    for(let i = 0; i < noOfRandomNums; i++)
    {
        document.write(randomNums[i] + " ");
    }
 
</script>

5 4 1 6 0 3 5 4 1 6

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 .