011 : Temel denizci bağları

 import numpy as np

def compute_corrected_integral(f, start, end, num_points):
    # 1. Tam sayı aralıkları
    step1 = (end - start) / num_points
    points1 = [start + step1 / 2 + i * step1 for i in range(num_points)]  # Step/2 ile başla, step ile ilerle
    values1 = [f(x) for x in points1]
    integral1 = np.trapz(values1, points1)

    # 2. Yarım noktalar (tam sayı noktaları hariç)
    step2 = step1 / 2
    points2 = [start + step2 / 2 + i * step2 for i in range(2 * num_points) if (start + step2 / 2 + i * step2) not in points1]
    values2 = [f(x) for x in points2]
    integral2 = np.trapz(values2, points2)

    # 3. Çeyrek noktalar (tam ve yarım noktalar hariç)
    step3 = step2 / 2
    points3 = [start + step3 / 2 + i * step3 for i in range(4 * num_points) if (start + step3 / 2 + i * step3) not in points1 + points2]
    values3 = [f(x) for x in points3]
    integral3 = np.trapz(values3, points3)

    # Geometrik dizinin farkları
    fark1 = integral2 - integral1  # İlk fark (geometrik dizinin ilk elemanı)
    fark2 = integral3 - integral2  # İkinci fark (geometrik dizinin ikinci elemanı)

    # Geometrik seriyi doğrudan oran kullanarak oluşturma
    oran = fark2 / fark1  # Fark oranı
    geometric_sum = fark2 * (1 / (1 - oran) - 1)  # Sonsuz toplam formülü: a / (1 - r)
    corrected_integral = integral3 + geometric_sum

    # Sonuçları yazdırma
    print("Tam sayı aralıkları (1. grup):")
    print("x değerleri:", points1)
    print("f(x) değerleri:", values1)
    print("Integral:", integral1)
    print("-" * 40)

    print("Yarım noktalar (2. grup):")
    print("x değerleri:", points2)
    print("f(x) değerleri:", values2)
    print("Integral:", integral2)
    print("-" * 40)

    print("Çeyrek noktalar (3. grup):")
    print("x değerleri:", points3)
    print("f(x) değerleri:", values3)
    print("Integral:", integral3)
    print("-" * 40)

    print("Geometrik dizinin ilk farkı:", fark1)
    print("Geometrik dizinin ikinci farkı:", fark2)
    print("Fark oranı:", oran)
    print("Düzeltilmiş integral:", corrected_integral)
    print("-" * 40)

    # Son olarak integral değerlerini döndürüyoruz
    return integral1, integral2, integral3, corrected_integral

# Fonksiyon tanımı (f(x) = x * x)
f = lambda x: x * x

# Parametreler
start = 0
end = 1
num_points = 1024  # İlk gruptaki bölme sayısı

# Hesaplama
integral1, integral2, integral3, corrected_integral = compute_corrected_integral(f, start, end, num_points)

# Sonuçları yazdırma
print("Integral1:", integral1)
print("Integral2:", integral2)
print("Integral3:", integral3)
print("Düzeltilmiş Integral:", corrected_integral)

Gabriel's Horn and the painter's paradox

Gabriel's Horn Paradox - Numberphile

 N Bob Pendlum with parallel computing

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from concurrent.futures import ThreadPoolExecutor

# Constants
L = 1.0  # Length of each pendulum segment
M = 1.0  # Mass of each pendulum segment

# Derivatives function
def derivs(state, num_pendulums, gravity):
    dydx = np.zeros_like(state)
    angles = state[:num_pendulums]
    velocities = state[num_pendulums:]

    for i in range(num_pendulums):
        if i == 0:
            dydx[i] = velocities[i]
            dydx[i + num_pendulums] = -gravity / L * np.sin(angles[i])
        else:
            dydx[i] = velocities[i]
            dydx[i + num_pendulums] = -gravity / L * (np.sin(angles[i]) - np.sin(angles[i - 1]))

    return dydx

# Integration function
def integrate(state, dt, num_pendulums, gravity):
    return state + dt * derivs(state, num_pendulums, gravity)

# Input from the user
num_pendulums = int(input("Enter the number of pendulums: "))
gravity = float(input("Enter the gravitational acceleration (m/s^2): "))

# Initial conditions
initial_angles = [np.pi / 2 for _ in range(num_pendulums)]
initial_velocities = [0 for _ in range(num_pendulums)]
state = np.array(initial_angles + initial_velocities, dtype='float64')
dt = 0.01
t = np.arange(0, 20, dt)

# Animation setup
fig, ax = plt.subplots(figsize=(8, 8))
max_length = num_pendulums * L
ax.set_xlim(-max_length, max_length)
ax.set_ylim(-max_length, max_length)

# Adjust line and bob thickness based on the number of pendulums
line_thickness = max(1, 6 - num_pendulums)
bob_size = max(1, 10 - num_pendulums)

lines, = ax.plot([], [], 'o-', lw=line_thickness, markersize=bob_size)

# Initialize the plot
def init():
    lines.set_data([], [])
    return lines,

# Update function for animation
def update(frame):
    global state
    with ThreadPoolExecutor() as executor:
        futures = [executor.submit(integrate, state, dt, num_pendulums, gravity) for _ in range(1)]
        for future in futures:
            state = future.result()

    x = np.cumsum([L * np.sin(angle) for angle in state[:num_pendulums]])
    y = np.cumsum([-L * np.cos(angle) for angle in state[:num_pendulums]])
    lines.set_data([0] + x.tolist(), [0] + y.tolist())
    return lines,

ani = FuncAnimation(fig, update, frames=len(t), init_func=init, blit=True, interval=10)
plt.show()

 import numpy as np

import matplotlib.pyplot as plt
from mpmath import zetazero, zeta, findroot

def plot_riemann_zeta_zeros(n_zeros):
    """Plot the first n_zeros non-trivial zeros of the Riemann zeta function."""
    # Get the first n_zeros non-trivial zeros
    zeros = [zetazero(n) for n in range(1, n_zeros + 1)]
    real_parts = [zero.real for zero in zeros]
    imaginary_parts = [zero.imag for zero in zeros]

    # Plot the zeros on the complex plane
    plt.figure(figsize=(10, 6))
    plt.scatter(real_parts, imaginary_parts, color='red', marker='x', label='Non-trivial zeros')
    plt.axhline(0, color='black', lw=0.5)
    plt.axvline(0.5, color='blue', lw=0.5, linestyle='--', label='Critical Line (Re=0.5)')
    plt.xlabel('Real Part')
    plt.ylabel('Imaginary Part')
    plt.title('Non-trivial Zeros of the Riemann Zeta Function')
    plt.legend()
    plt.grid(True)
    plt.show()

# Example usage
plot_riemann_zeta_zeros(200)

 Python: Butterfly effect graph 3D

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Constants
sigma = 10.0
rho = 28.0
beta = 8.0 / 3.0

# Time parameters
dt = 0.01
num_steps = 10000

# Initial conditions
x0, y0, z0 = 0.0, 1.0, 1.05

# Arrays to store trajectories
x = np.empty(num_steps + 1)
y = np.empty(num_steps + 1)
z = np.empty(num_steps + 1)
x[0], y[0], z[0] = x0, y0, z0

# Lorenz system equations
def lorenz(x, y, z, sigma, rho, beta):
    dx = sigma * (y - x)
    dy = x * (rho - z) - y
    dz = x * y - beta * z
    return dx, dy, dz

# Integrate the Lorenz equations
for i in range(num_steps):
    dx, dy, dz = lorenz(x[i], y[i], z[i], sigma, rho, beta)
    x[i + 1] = x[i] + dx * dt
    y[i + 1] = y[i] + dy * dt
    z[i + 1] = z[i] + dz * dt

# Animation setup
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection='3d')
ax.set_xlim(-20, 20)
ax.set_ylim(-30, 30)
ax.set_zlim(0, 50)
line, = ax.plot([], [], [], lw=2)
plt.title('Lorenz Attractor')

def init():
    line.set_data(np.array([]), np.array([]))
    line.set_3d_properties(np.array([]))
    return line,

def update(frame):
    line.set_data(x[:frame], y[:frame])
    line.set_3d_properties(z[:frame])
    return line,

ani = FuncAnimation(fig, update, frames=num_steps, init_func=init, blit=True, interval=1)
plt.show()