Source Code Metode Beda Hingga dengan R

Pada code berikut ini persamaan yang dipakai adalah m * d^2x/dt^2 + k * x = 0. Sebelum running program, pastikan sudah menginstall package deSolve.

library(deSolve)
# Function defining the ODE system
ode_function <- function(t, y, parameters) {
  # Extract the variables
  x <- y[1]
  v <- y[2]
  # Extract the parameters
  k <- parameters$k
  m <- parameters$m
  # Definisikan ODEs
  dxdt <- v  # dx/dt = v
  dvdt <- -k/m * x  # dv/dt = -k/m * x
  
  # Return the derivatives
  return(list(c(dxdt, dvdt)))
}

# Tetapkan kondisi awal dan parameter
initial_conditions <- c(x = 1, v = 0)  # posisi awal san kecepatan
parameters <- list(k = 1, m = 1)  # kontstanta pegas dan massa
# Set time points for integration
time_points <- seq(0, 10, by = 0.1)
# Selesaikan sistem ODE dengan metode beda hingga
solution <- ode(initial_conditions, time_points, ode_function, parameters)
# Extract the position values from the solution
positions <- solution[, "x"]
# Plot hasil simulasi
plot(time_points, positions, xlab = "Time", ylab = "Position", type = "l", main = "Simulation Results")

Source Code Algoritma Genetika dengan Python

 import numpy as np

# Inisialisasi populasi awal
def initialize_population(population_size, chromosome_length):
population = np.random.randint(2, size=(population_size, chromosome_length))
return population

# Evaluasi fitness individu
def fitness_function(chromosome):
# Misalkan kita ingin memaksimalkan jumlah bit yang bernilai 1
return np.sum(chromosome)

# Evaluasi fitness populasi
def evaluate_population(population):
fitness_values = np.zeros(len(population))
for i in range(len(population)):
fitness_values[i] = fitness_function(population[i])
return fitness_values

# Seleksi orangtua menggunakan turnamen
def tournament_selection(population, fitness_values, tournament_size):
selected_parents = np.zeros((2, len(population[0])))
for i in range(2):
tournament_indices = np.random.choice(len(population), tournament_size, replace=False)
tournament_fitness = fitness_values[tournament_indices]
winner_index = tournament_indices[np.argmax(tournament_fitness)]
selected_parents[i] = population[winner_index]
return selected_parents

# Crossover menggunakan satu titik potong
def crossover(parents):
crossover_point = np.random.randint(1, len(parents[0]))
child1 = np.concatenate((parents[0][:crossover_point], parents[1][crossover_point:]))
child2 = np.concatenate((parents[1][:crossover_point], parents[0][crossover_point:]))
return child1, child2

# Mutasi dengan probabilitas mutasi
def mutation(chromosome, mutation_rate):
for i in range(len(chromosome)):
if np.random.rand() < mutation_rate:
chromosome[i] = 1 - chromosome[i] # Flip the bit
return chromosome

# Algoritma genetika
def genetic_algorithm(population_size, chromosome_length, tournament_size, mutation_rate, num_generations):
population = initialize_population(population_size, chromosome_length)
best_fitness = np.zeros(num_generations)

for generation in range(num_generations):
fitness_values = evaluate_population(population)
best_fitness[generation] = np.max(fitness_values)

selected_parents = tournament_selection(population, fitness_values, tournament_size)
new_population = np.zeros((population_size, chromosome_length))

for i in range(0, population_size, 2):
child1, child2 = crossover(selected_parents)
new_population[i] = mutation(child1, mutation_rate)
new_population[i+1] = mutation(child2, mutation_rate)

population = new_population

best_chromosome = population[np.argmax(fitness_values)]
return best_chromosome, best_fitness

# Pengaturan parameter
population_size = 100
chromosome_length = 20
tournament_size = 5
mutation_rate = 0.01
num_generations = 100

# Menjalankan algoritma genetika
best_chromosome, best_fitness = genetic_algorithm(population_size, chromosome_length, tournament_size, mutation_rate, num_generations)

# Output hasil
print("Best Chromosome:", best_chromosome)
print("Best Fitness:", np.max(best_fitness))

Source Code Python Metode Beda Hingga

import numpy as np
import matplotlib.pyplot as plt

def finite_difference_method(x_start, x_end, num_points, initial_condition, boundary_condition):
# Inisialisasi parameter
delta_x = (x_end - x_start) / (num_points - 1)
x = np.linspace(x_start, x_end, num_points)
u = np.zeros(num_points)
u[0] = boundary_condition[0]
u[-1] = boundary_condition[1]

# Iterasi menggunakan metode beda hingga
for i in range(1, num_points - 1):
u[i] = u[i-1] + initial_condition(x[i]) * delta_x

return x, u

# Fungsi persamaan diferensial: u'(x) = x^2 + sin(x)
def initial_condition(x):
return x**2 + np.sin(x)

# Contoh batasan: u(0) = 0, u(1) = 1
boundary_condition = (0, 1)

# Parameter untuk grid
x_start = 0
x_end = 1
num_points = 100

# Menggunakan metode beda hingga
x, u = finite_difference_method(x_start, x_end, num_points, initial_condition, boundary_condition)

# Plot hasil solusi numerik
plt.plot(x, u, label='Numerical Solution')
plt.xlabel('x')
plt.ylabel('u(x)')
plt.title('Finite Difference Method')
plt.legend()
plt.grid(True)
plt.show()

Output Program f(x)=x^2+sin(x)