Continuous Systems

import matplotlib.pyplot as plt

class ChemicalReaction:
    def __init__(self, k1, k2, c1, c2, c3, time_diff=0.1):
        self.k1 = k1  # Rate constant for forward reaction
        self.k2 = k2  # Rate constant for reverse reaction
        self.c1 = c1  # Initial concentration of A
        self.c2 = c2  # Initial concentration of B
        self.c3 = c3  # Initial concentration of C
        self.time_diff = time_diff  # Time step for simulation

        self.time_points = [0]
        self.concentration_A = [c1]
        self.concentration_B = [c2]
        self.concentration_C = [c3]

    def simulate_reaction(self, total_time):
        steps = int(total_time / self.time_diff)
        for step in range(1, steps + 1):
            current_time = step * self.time_diff
            a = self.concentration_A[-1]
            b = self.concentration_B[-1]
            c = self.concentration_C[-1]

            # Calculate changes
            delta_a = (-self.k1 * a * b + self.k2 * c) * self.time_diff
            delta_b = (-self.k1 * a * b + self.k2 * c) * self.time_diff
            delta_c = 2 * (self.k1 * a * b - self.k2 * c) * self.time_diff

            # Update 
            new_a = a + delta_a
            new_b = b + delta_b
            new_c = c + delta_c

            # Append 
            self.time_points.append(current_time)
            self.concentration_A.append(new_a)
            self.concentration_B.append(new_b)
            self.concentration_C.append(new_c)

    def print_results(self):
        print("Time\t[A]\t[B]\t[C]")
        for t, a, b, c in zip(self.time_points, self.concentration_A, self.concentration_B, self.concentration_C):
            print(f"{t:.2f}\t{a:.4f}\t{b:.4f}\t{c:.4f}")

    def plot_concentrations(self):
        plt.plot(self.time_points, self.concentration_A, label='[A]', color='blue')
        plt.plot(self.time_points, self.concentration_B, label='[B]', color='orange')
        plt.plot(self.time_points, self.concentration_C, label='[C]', color='green')
        plt.title('Concentration vs Time')
        plt.xlabel('Time')
        plt.ylabel('Concentration')
        plt.legend()
        plt.grid()
        plt.show()

if __name__ == "__main__":
    reaction = ChemicalReaction(k1=0.025, k2=0.01, c1=50.0, c2=25.0, c3=0.0)
    reaction.simulate_reaction(total_time=15)
    reaction.print_results()
    reaction.plot_concentrations()

import math
import matplotlib.pyplot as plt

# Fighter coordinates
xf = [0]
yf = [50]
speed = 20  # Fighter speed
capture_distance = 10  # Distance at which the fighter captures the bomber

# Bomber coordinates
xb = [100, 100, 120, 129, 140, 149, 158, 168, 179, 188, 198, 209, 219, 226, 234, 240]
yb = [0, 3, 6, 10, 15, 20, 26, 32, 37, 34, 30, 27, 23, 19, 16, 14]

def calc_distance(x1, y1, x2, y2):
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def sin_theta(x1, y1, x2, y2):
    return (y2 - y1) / calc_distance(x1, y1, x2, y2)

def cos_theta(x1, y1, x2, y2):
    return (x2 - x1) / calc_distance(x1, y1, x2, y2)

def simulate_flight():
    global xf, yf, xb, yb, speed, capture_distance
    iteration = 0

    while True:
        xf = xf + [xf[-1] + speed * cos_theta(xf[-1], yf[-1], xb[iteration], yb[iteration])]
        yf = yf + [yf[-1] + speed * sin_theta(xf[-1], yf[-1], xb[iteration], yb[iteration])]

        distance = calc_distance(xf[iteration], yf[iteration], xb[iteration], yb[iteration])
        print("Iteration:", iteration+1, "Distance:", distance)
        iteration += 1
        if distance <= capture_distance or len(xf) >= len(xb):
            break

def plot_flight():
    plt.plot(xf, yf, label='Fighter Path', color='blue')
    plt.plot(xb, yb, label='Bomber Path', color='red')
    plt.scatter(xf[-1], yf[-1], color='green', label='Capture Point')
    plt.title('Fighter and Bomber Flight Paths')
    plt.xlabel('X Coordinate')
    plt.ylabel('Y Coordinate')
    plt.legend()
    plt.grid()
    plt.show()

def plot_fight_animation():
    plt.ion()
    fig, ax = plt.subplots()
    ax.set_xlim(0, 250)
    ax.set_ylim(0, 100)
    fighter_line, = ax.plot([], [], 'b-', label='Fighter Path')
    bomber_line, = ax.plot([], [], 'r-', label='Bomber Path')
    fighter_point, = ax.plot([], [], 'bo', label='Fighter')
    bomber_point, = ax.plot([], [], 'ro', label='Bomber')
    ax.legend()
    ax.grid()

    for i in range(len(xf)):
        fighter_line.set_data(xf[:i+1], yf[:i+1])
        bomber_line.set_data(xb[:i+1], yb[:i+1])
        fighter_point.set_data(xf[:i], yf[:i])
        bomber_point.set_data(xb[:i], yb[:i])
        plt.pause(0.5)

    plt.ioff()
    plt.show()

simulate_flight()
plot_flight()

# Run the animation in a single file for better compatibility
# plot_fight_animation()

import math
from mpl_toolkits.mplot3d import Axes3D

import matplotlib.pyplot as plt

# Fighter coordinates
xf = [0]
yf = [50]
zf = [0]
speed = 20  # Fighter speed
capture_distance = 10  # Distance at which the fighter captures the bomber

# Bomber coordinates
xb = [100, 100, 120, 129, 140, 149, 158, 168, 179, 188, 198, 209, 219, 226, 234, 240]
yb = [0, 3, 6, 10, 15, 20, 26, 32, 37, 34, 30, 27, 23, 19, 16, 14]
zb = [0, 5, 10, 15, 20, 25, 28, 30, 32, 30, 28, 25, 20, 15, 10, 5]

def calc_distance(x1, y1, z1, x2, y2, z2):
    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2 + (z2 - z1) ** 2)

def sin_theta(x1, y1, z1, x2, y2, z2):
    return (y2 - y1) / calc_distance(x1, y1, z1, x2, y2, z2)

def cos_theta(x1, y1, z1, x2, y2, z2):
    return (x2 - x1) / calc_distance(x1, y1, z1, x2, y2, z2)

def sin_phi(x1, y1, z1, x2, y2, z2):
    return (z2 - z1) / calc_distance(x1, y1, z1, x2, y2, z2)

def simulate_flight():
    global xf, yf, zf, xb, yb, zb, speed, capture_distance
    iteration = 0

    while True:
        xf = xf + [xf[-1] + speed * cos_theta(xf[-1], yf[-1], zf[-1], xb[iteration], yb[iteration], zb[iteration])]
        yf = yf + [yf[-1] + speed * sin_theta(xf[-1], yf[-1], zf[-1], xb[iteration], yb[iteration], zb[iteration])]
        zf = zf + [zf[-1] + speed * sin_phi(xf[-1], yf[-1], zf[-1], xb[iteration], yb[iteration], zb[iteration])]

        distance = calc_distance(xf[iteration], yf[iteration], zf[iteration], xb[iteration], yb[iteration], zb[iteration])
        print("Iteration:", iteration+1, "Distance:", distance)
        iteration += 1
        if distance <= capture_distance or len(xf) >= len(xb):
            break

def plot_flight():
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.plot(xf, yf, zf, label='Fighter Path', color='blue')
    ax.plot(xb, yb, zb, label='Bomber Path', color='red')
    ax.scatter(xf[-1], yf[-1], zf[-1], color='green', label='Capture Point')
    ax.set_title('Fighter and Bomber Flight Paths (3D)')
    ax.set_xlabel('X Coordinate')
    ax.set_ylabel('Y Coordinate')
    ax.set_zlabel('Z Coordinate')
    ax.legend()
    plt.show()

def plot_fight_animation():
    plt.ion()
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax.set_xlim(0, 250)
    ax.set_ylim(0, 100)
    ax.set_zlim(0, 40)
    fighter_line, = ax.plot([], [], [], 'b-', label='Fighter Path')
    bomber_line, = ax.plot([], [], [], 'r-', label='Bomber Path')
    fighter_point, = ax.plot([], [], [], 'bo', label='Fighter')
    bomber_point, = ax.plot([], [], [], 'ro', label='Bomber')
    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.set_zlabel('Z')
    ax.legend()
    ax.grid()

    for i in range(len(xf)):
        fighter_line.set_data(xf[:i+1], yf[:i+1])
        fighter_line.set_3d_properties(zf[:i+1])
        bomber_line.set_data(xb[:i+1], yb[:i+1])
        bomber_line.set_3d_properties(zb[:i+1])
        fighter_point.set_data([xf[i]], [yf[i]])
        fighter_point.set_3d_properties([zf[i]])
        bomber_point.set_data([xb[i]], [yb[i]])
        bomber_point.set_3d_properties([zb[i]])
        plt.pause(0.5)

    plt.ioff()
    plt.show()

simulate_flight()
plot_flight()

import math
import matplotlib.pyplot as plt

A, B, C, D = (0, 0), (0,10), (0,20), (0,30)

A_history = [A]
B_history = [B]
C_history = [C]
D_history = [D]

vA, vB, vC, vD = 30, 25, 20, 15
target_d = (30, 50)

def distance(p1, p2):
    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)

t = 0

for i in range(10):
    t += 0.1

    # Move A towards B
    a_to_b = distance(A, B)
    if a_to_b < 0.005:
        print(f"A hits B at time {t:.2f} hours")
        break
    A = (A[0] + vA * 0.1 * (B[0] - A[0]) / a_to_b, A[1] + vA * 0.1 * (B[1] - A[1]) / a_to_b)
    A_history.append(A)

    # Move B towards C
    b_to_c = distance(B, C)
    if b_to_c < 0.005:
        print(f"B hits C at time {t:.2f} hours")
        break
    B = (B[0] + vB * 0.1 * (C[0] - B[0]) / b_to_c, B[1] + vB * 0.1 * (C[1] - B[1]) / b_to_c)
    B_history.append(B)

    # Move C towards D
    c_to_d = distance(C, D)
    if c_to_d < 0.005:
        print(f"C hits D at time {t:.2f} hours")
        break
    C = (C[0] + vC * 0.1 * (D[0] - C[0]) / c_to_d, C[1] + vC * 0.1 * (D[1] - C[1]) / c_to_d)
    C_history.append(C)

    # Move D towards target
    d_to_target = distance(D, target_d)
    if d_to_target < 0.005:
        print(f"D hits the target at time {t:.2f} hours")
        break
    D = (D[0] + vD * 0.1 * (target_d[0] - D[0]) / d_to_target, D[1] + vD * 0.1 * (target_d[1] - D[1]) / d_to_target)
    D_history.append(D)

    # Preety-Print
    print(f"T: {t:.2f},\n A: ({A[0]:.2f}, {A[1]:.2f}), B: ({B[0]:.2f}, {B[1]:.2f}), C: ({C[0]:.2f}, {C[1]:.2f}), D: ({D[0]:.2f}, {D[1]:.2f}), AB: {a_to_b:.2f}, BC: {b_to_c:.2f}, CD: {c_to_d:.2f}, DTarget: {d_to_target:.2f}\n")

# Plotting the paths
plt.plot(*zip(*A_history), label='A Path', color='blue')
plt.plot(*zip(*B_history), label='B Path', color='orange')
plt.plot(*zip(*C_history), label='C Path', color='green')
plt.plot(*zip(*D_history), label='D Path', color='red')
plt.scatter(target_d[0], target_d[1], color='purple', label='Target', marker='X')
plt.title('Paths of A, B, C, D and Target')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')
plt.legend()
plt.grid()
plt.show()