import numpy as np
import matplotlib.pyplot as plt

# Define the parameters of the uniform distribution
a = 0  # Minimum value
b = 10  # Maximum value

# Generate x values within the range [a, b]
x = np.linspace(a, b, 1000)

# Calculate the PDF values for each x
pdf_values = np.full_like(x, 1 / (b - a))

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Uniform Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Define the parameters of the normal distribution
mu = 0  # Mean
sigma = 1  # Standard deviation

# Generate x values within a certain range
x = np.linspace(mu - 3 * sigma, mu + 3 * sigma, 1000)

# Calculate the PDF values for each x
pdf_values = np.exp(-(x - mu)**2 / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Normal Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Define the parameter of the exponential distribution
lambda_val = 0.5  # Rate parameter

# Generate x values within a certain range
x = np.linspace(0, 10, 1000)

# Calculate the PDF values for each x
pdf_values = lambda_val * np.exp(-lambda_val * x)

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Exponential Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.special import factorial

# Define the parameter of the Poisson distribution
lambda_val = 5  # Average rate

# Generate x values within a certain range
x = np.arange(0, 21)

# Calculate the PMF values for each x
pmf_values = np.exp(-lambda_val) * (lambda_val ** x) / factorial(x)

# Plot the PMF
plt.stem(x, pmf_values)
plt.xlabel('x')
plt.ylabel('Probability Mass')
plt.title('Poisson Distribution PMF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import binom

# Define the parameters of the binomial distribution
n = 10  # Number of trials
p = 0.5  # Probability of success

# Generate x values within a certain range
x = np.arange(0, n + 1)

# Calculate the PMF values for each x
pmf_values = binom.pmf(x, n, p)

# Plot the PMF
plt.stem(x, pmf_values)
plt.xlabel('x')
plt.ylabel('Probability Mass')
plt.title('Binomial Distribution PMF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import geom

# Define the parameter of the geometric distribution
p = 0.5  # Probability of success

# Generate x values within a certain range
x = np.arange(1, 11)

# Calculate the PMF values for each x
pmf_values = geom.pmf(x, p)

# Plot the PMF
plt.stem(x, pmf_values)
plt.xlabel('x')
plt.ylabel('Probability Mass')
plt.title('Geometric Distribution PMF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import gamma

# Define the parameters of the gamma distribution
k = 2  # Shape parameter
theta = 1  # Scale parameter

# Generate x values within a certain range
x = np.linspace(0, 10, 1000)

# Calculate the PDF values for each x
pdf_values = gamma.pdf(x, k, scale=theta)

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Gamma Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import beta

# Define the parameters of the beta distribution
alpha = 2  # Shape parameter
beta_val = 2  # Shape parameter

# Generate x values within a certain range
x = np.linspace(0, 1, 1000)

# Calculate the PDF values for each x
pdf_values = beta.pdf(x, alpha, beta_val)

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Beta Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import lognorm

# Define the parameters of the lognormal distribution
mu = 0  # Mean of the underlying normal distribution
sigma = 1  # Standard deviation of the underlying normal distribution

# Generate x values within a certain range
x = np.linspace(0, 10, 1000)

# Calculate the PDF values for each x
pdf_values = lognorm.pdf(x, sigma, scale=np.exp(mu))

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Lognormal Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def triangular_pdf(x, a, b, c):
    if a <= x <= c:
        return (2 / (b - a)) * (x - a) / (c - a)
    elif c <= x <= b:
        return (2 / (b - a)) * (b - x) / (b - c)
    else:
        return 0

# Define the parameters of the triangular distribution
a = 0
b = 10
c = 5

# Generate x values within the range [a, b]
x = np.linspace(a, b, 1000)

# Calculate the PDF values for each x
pdf_values = [triangular_pdf(val, a, b, c) for val in x]

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Triangular Distribution PDF')
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Define the parameters of the triangular distribution
a = 0  # Minimum value
b = 10  # Maximum value
c = 5  # Mode value

# Generate x values within the range [a, b]
x = np.linspace(a, b, 1000)

# Calculate the PDF values for each x
pdf_values = np.piecewise(x, [x < c, x >= c], [lambda x: 2 * (x - a) / ((b - a) * (c - a)), lambda x: 2 * (b - x) / ((b - a) * (b - c))])

# Plot the PDF
plt.plot(x, pdf_values)
plt.xlabel('x')
plt.ylabel('Probability Density')
plt.title('Triangular DistributionPDF')
plt.grid(True)
plt.show()

# Example-1
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# Creating an instance of the Person class
person1 = Person("Arun", 35)
person2 = Person('Nidhi', 31)

# Accessing the object's attributes
print(person1.name)  # Output: Arun
print(person1.age)   # Output: 35

# Calling the object's method
person1.introduce()  # Output: Hello, my name is Arun and I am 35 years old.

Arun
35
Hello, my name is Arun and I am 35 years old.

person1.introduce()
person2.introduce()

Hello, my name is Arun and I am 35 years old.
Hello, my name is Nidhi and I am 31 years old.

# Example- 2
# Python program to demonstrate init with inheritance

class A(object):
    def __init__(self, something):
        print("A init called")
        self.something = something

class B(A):
    def __init__(self, something):
        # Calling init of parent class
        A.__init__(self, something)
        print("B init called")
        self.something = something
 
obj = B("Something")

A init called
B init called

# Example-3

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def display(self):
        print(f"Name: {self.name}, Age: {self.age}")


class Employee(Person):
    def __init__(self, name, age, employee_id):
        super().__init__(name, age)
        self.employee_id = employee_id

    def display_employee(self):
        print(f"Employee ID: {self.employee_id}")


person = Person("John", 25)
person.display()

employee = Employee("Jane", 30, "E123")
employee.display()
employee.display_employee()

Name: John, Age: 25
Name: Jane, Age: 30
Employee ID: E123

class PRNG:
    def __init__(self, seed):
        self.seed = seed
        self.multiplier = 1103515245
        self.increment = 12345
        self.modulus = 2**31

    def generate(self):
        self.seed = (self.multiplier * self.seed + self.increment) % self.modulus
        return self.seed

# Example usage
prng = PRNG(seed=1)
for _ in range(10):
    random_number = prng.generate()
    print(random_number)

1103527590
377401575
662824084
1147902781
2035015474
368800899
1508029952
486256185
1062517886
267834847

# Example-4 on LCG
class LCG:
    def __init__(self, seed, a, c, m):
        self.seed = seed
        self.a = a
        self.c = c
        self.m = m

    def generate(self):
        self.seed = (self.a * self.seed + self.c) % self.m
        return self.seed

# Example usage
lcg = LCG(seed=1, a=1103515245, c=12345, m=2**31)
for _ in range(10):
    random_number = lcg.generate()
    print(random_number)

1103527590
377401575
662824084
1147902781
2035015474
368800899
1508029952
486256185
1062517886
267834847

# Example-5
class LCG:
    def __init__(self, seed, a, c, m):
        self.seed = seed
        self.a = a
        self.c = c
        self.m = m

    def generate(self):
        self.seed = (self.a * self.seed + self.c) % self.m
        return self.seed / self.m

# Example usage
lcg = LCG(seed=42, a=1664525, c=1013904223, m=2**32)
for _ in range(10):
    random_number = lcg.generate()
    scaled_number = random_number * 10  # Scale the range to 0-10
    print(scaled_number)

2.5234517478384078
0.8812504541128874
5.772811982315034
2.22554265987128
3.7566019711084664
0.2566390484571457
4.472812858875841
1.184600037522614
8.738137057516724
9.946342753246427

import matplotlib.pyplot as plt

class LCG:
    def __init__(self, seed, a, c, m):
        self.seed = seed
        self.a = a
        self.c = c
        self.m = m

    def generate(self):
        self.seed = (self.a * self.seed + self.c) % self.m
        return self.seed


def generate_random_numbers(lcg, n):
    random_numbers = []
    for _ in range(n):
        random_number = lcg.generate()
        random_numbers.append(random_number)
    return random_numbers


# Example usage
lcg = LCG(seed=1, a=48271, c=0, m=2**31 - 1)
random_numbers = generate_random_numbers(lcg, n=10000)

# Plotting x_n with respect to x_{n-1}
x_n = random_numbers[1:]
x_n_minus_1 = random_numbers[:-1]

plt.scatter(x_n_minus_1, x_n, s=1, color='black')  # Decrease the point size by adjusting 's'
plt.xlabel('$x_{n-1}$')
plt.ylabel('$x_n$')
plt.title('$x_n$ vs $x_{n-1}$')
plt.show()

class LCG:
    def __init__(self, seed, a, c, m):
        self.seed = seed
        self.a = a
        self.c = c
        self.m = m

    def generate(self):
        new_seed = (self.a * self.seed + self.c) % self.m
        return new_seed

def generate_table(lcg1, n):
    header = ['n', '(a * X_n + c)', 'X_{n+1}', '% m']
    table = [header]

    for i in range(n):
        random_number = lcg1.generate()
        row = [i+1, lcg1.a * lcg1.seed + lcg1.c, random_number, random_number % lcg1.m]
        table.append(row)
        lcg1.seed = random_number

    return table


# Example usage
lcg1 = LCG(seed=1, a=48271, c=0, m=2**31 - 1)
random_table = generate_table(lcg1, n=10)

# Printing the table
for row in random_table:
    print('{:<10} {:<20} {:<15} {:<13}'.format(*row))

n          (a * X_n + c)        X_{n+1}         % m          
1          48271                48271           48271        
2          2330089441           182605794       182605794    
3          8814564282174        1291394886      1291394886   
4          62336922542106       1914720637      1914720637   
5          92425479868627       2078669041      2078669041   
6          100339433278111      407355683       407355683    
7          19663466174093       1105902161      1105902161   
8          53383003213631       854716505       854716505    
9          41258020412855       564586691       564586691    
10         27253164161261       1596680831      1596680831

Monte-Carlo-Simulation

Author: Arun Kumar Pandey

Monte Carlo simulations and Machine learning algorithms¶

Introduction to Monte Carlo Simulation

Basic Principles

Steps in Monte Carlo Simulation

Statistics

1. Understand the Basics statistics

2. Learn Probability Distributions

2.1. Uniform Distribution:¶

2.2. Normal (Gaussian) Distribution:¶

2.3. Exponential Distribution¶

2.4. Poisson Distribution:¶

2.5. Binomial Distribution:¶

2.6. Geometric Distribution:¶

2.7. Gamma Distribution:¶

2.8. Beta Distribution:¶

2.9. Lognormal Distribution:¶

2.10. Triangular Distribution:¶

Generating Random Numbers

Random Number Generation

Applications of random number generation and simulations:¶

Categories of randaom number generators¶

Examples

Variance Reduction Techniques

1. Antithetic Variates:¶

2. Control Variates:¶

3. Importance Sampling:¶

4. Stratified Sampling:¶

5. Importance Sampling:¶

Applications of Monte Carlo Simulation

Pseudorandom Number Generators (PRNGs):

How a typical PRNG works?¶

Common PRNG algorithms¶

1. Linear congruential generators (LCGs)¶

2. Mersenne Twister¶

3. XORshift¶

4. Multiply-with-carry¶

Reference¶