Source Code-

def fuzzy_union(a, b):

result = []

for i in range(len(a)):

result.append(max(a[i], b[i]))

return result

def fuzzy_intersection(a, b):

result = []

for i in range(len(a)):

result.append(min(a[i], b[i]))

return result

def fuzzy_complement(a):

result = []

for i in range(len(a)):

result.append(1 - a[i])

return result

# Example usage

a = [0.2, 0.4, 0.6]

b = [0.5, 0.3, 0.7]

# Fuzzy union

union_result = fuzzy_union(a, b)

print("Union:", union_result)

# Fuzzy intersection

intersection_result = fuzzy_intersection(a, b)

print("Intersection:", intersection_result)

# Fuzzy complement

complement_result = fuzzy_complement(a)

print("Complement:", complement_result)
Source Code-
import random

import numpy as np

# City class to represent a city with x and y coordinates

class City:

def __init__(self, x, y):

self.x = x

self.y = y

def distance_to(self, city):

x_distance = abs(self.x - city.x)

y_distance = abs(self.y - city.y)

return np.sqrt((x_distance ** 2) + (y_distance ** 2))

# Genetic Algorithm class

class GeneticAlgorithm:

def __init__(self, population_size, generations, mutation_rate, cities):

self.population_size = population_size

self.generations = generations

self.mutation_rate = mutation_rate

self.cities = cities

def create_initial_population(self):

population = []

for _ in range(self.population_size):

population.append(random.sample(self.cities, len(self.cities)))

return population

def calculate_fitness(self, individual):

total_distance = 0

for i in range(len(individual) - 1):

current_city = individual[i]

next_city = individual[i + 1]

total_distance += current_city.distance_to(next_city)

return 1 / total_distance
 def selection(self, population):

fitness_scores = [self.calculate_fitness(individual) for individual in population]

total_fitness = sum(fitness_scores)

probabilities = [fitness_score / total_fitness for fitness_score in fitness_scores]

selected_indices = random.choices(range(len(population)), weights=probabilities,

k=len(population))

return [population[index] for index in selected_indices]

def crossover(self, parent1, parent2):

child = [None] * len(parent1)

start_index = random.randint(0, len(parent1) - 1)

end_index = random.randint(start_index + 1, len(parent1))

child[start_index:end_index] = parent1[start_index:end_index]

for city in parent2:

if city not in child:

for i in range(len(child)):

if child[i] is None:

child[i] = city

break

return child

def mutate(self, individual):

for i in range(len(individual)):

if random.random() < self.mutation_rate:

j = random.randint(0, len(individual) - 1)

individual[i], individual[j] = individual[j], individual[i]

return individual

def evolve(self):

population = self.create_initial_population()

for _ in range(self.generations):

population = self.selection(population)

new_population = []

while len(new_population) < self.population_size:

 parent1 = random.choice(population)

parent2 = random.choice(population)

child = self.crossover(parent1, parent2)

child = self.mutate(child)

new_population.append(child)

population = new_population

best_individual = max(population, key=self.calculate_fitness)

return best_individual

city1 = City(0, 0)

city2 = City(1, 5)

city3 = City(3, 2)

city4 = City(6, 6)

city5 = City(8, 3)

cities = [city1, city2, city3, city4, city5]

ga = GeneticAlgorithm(population_size=50, generations=100, mutation_rate=0.01, cities=cities)

best_route = ga.evolve()

print("Best route found:")

for city in best_route:

print("City ({}, {})".format(city.x, city.y))