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()

 Python Deli Prof

import numpy as np
import sympy as sp
import decimal
from decimal import Decimal, getcontext
import matplotlib.pyplot as plt

# Sayısal Integral Hesaplama Fonksiyonu
def numerical_integral():
    func_expr = input("Enter the function f(x) to integrate: ")
    try:
        func = eval("lambda x: " + func_expr, {"__builtins__": None},
                    {"np": np, "sin": np.sin, "cos": np.cos, "exp": np.exp, "log": np.log, "sqrt": np.sqrt})
        a = float(input("Enter the lower limit of integration (a): "))
        b = float(input("Enter the upper limit of integration (b): "))
        x = np.linspace(a, b, 1000)
        y = func(x)
        integral_value = np.trapz(y, x)
        print(f"The integral of the function from {a} to {b} is approximately {integral_value}")
    except Exception as e:
        print(f"Error in evaluating the function: {e}")

# Sembolik Integral Hesaplama Fonksiyonu
def symbolic_integral():
    x = sp.symbols('x')
    function_expr = input("Enter the function f(x) to integrate: ")
    try:
        func = sp.sympify(function_expr)
        integral = sp.integrate(func, x)
        print(f"The integral of {sp.pretty(func)} with respect to x is:")
        print(sp.pretty(integral))
    except Exception as e:
        print(f"Error in evaluating the function: {e}")

# Asal Sayıları Bulma Fonksiyonu
def find_primes():
    start = int(input("Enter the starting number of the range: "))
    end = int(input("Enter the ending number of the range: "))
    primes = []
    for num in range(start, end + 1):
        is_prime = all(num % i != 0 for i in range(2, int(num ** 0.5) + 1))
        if is_prime and num > 1:
            primes.append(num)
    print(f"Prime numbers between {start} and {end} are: {primes}")

# İkiz Asal Sayıları Bulma Fonksiyonu
def find_twin_primes():
    start = int(input("Enter the starting number of the range: "))
    end = int(input("Enter the ending number of the range: "))
    twin_primes = []
    primes = []
    for num in range(start, end + 1):
        is_prime = all(num % i != 0 for i in range(2, int(num ** 0.5) + 1))
        if is_prime and num > 1:
            primes.append(num)
    for i in range(len(primes) - 1):
        if primes[i + 1] - primes[i] == 2:
            twin_primes.append((primes[i], primes[i + 1]))
    print(f"Twin prime numbers between {start} and {end} are: {twin_primes}")
# Kuvvet Hesaplama Fonksiyonu
def high_precision_power():
    base = Decimal(input("Enter the base number: "))
    exponent = Decimal(input("Enter the exponent: "))
    precision = int(input("Enter the number of decimal places: "))
    getcontext().prec = precision + 2  # Ekstra iki hane daha doğru sonuçlar için
    result = base ** exponent
    print(f"The result of {base} raised to the power of {exponent} to {precision} decimal places is:")
    print(f"{result:.{precision}f}")

# Kök Bulma (Root Finding) Fonksiyonu
def root_finding():
    x = sp.symbols('x')
    function_expr = input("Enter the function f(x): ")
    func = sp.sympify(function_expr)
    initial_guess = float(input("Enter an initial guess: "))
    root = sp.nsolve(func, x, initial_guess)
    print(f"A root of the function is: {root}")

# İstatistiksel Analiz Fonksiyonu
def statistical_analysis():
    data = list(map(float, input("Enter the data set (comma-separated): ").split(',')))
    mean = np.mean(data)
    median = np.median(data)
    std_dev = np.std(data)
    print(f"Mean: {mean}, Median: {median}, Standard Deviation: {std_dev}")
# Eğri Uydurma (Curve Fitting) Fonksiyonu
def curve_fitting():
    x_data = list(map(float, input("Enter the x data points (comma-separated): ").split(',')))
    y_data = list(map(float, input("Enter the y data points (comma-separated): ").split(',')))
    degree = int(input("Enter the degree of the polynomial to fit: "))
    coeffs = np.polyfit(x_data, y_data, degree)
    poly = np.poly1d(coeffs)
    print(f"Fitted polynomial: {poly}")

# Diferansiyel Denklemler Çözme Fonksiyonu
def solve_differential_equation():
    x = sp.symbols('x')
    y = sp.Function('y')
    eq = input("Enter the differential equation (in terms of y(x)): ")
    deqn = sp.sympify(eq)
    solution = sp.dsolve(deqn, y(x))
    print(f"The solution is: {solution}")

# Matris İşlemleri Fonksiyonu
def matrix_operations():
    rows = int(input("Enter the number of rows for the matrix: "))
    cols = int(input("Enter the number of columns for the matrix: "))
    print("Enter the elements of the matrix row-wise:")
    matrix = [[float(input()) for _ in range(cols)] for _ in range(rows)]
    mat = np.array(matrix)
    determinant = np.linalg.det(mat)
    inverse = np.linalg.inv(mat) if determinant != 0 else None
    print(f"Determinant: {determinant}")
    print(f"Inverse: {inverse}" if inverse is not None else "Inverse does not exist.")
# Kompleks Sayı İşlemleri Fonksiyonu
def complex_number_operations():
    z1 = complex(input("Enter the first complex number (in the form a+bj): "))
    z2 = complex(input("Enter the second complex number (in the form a+bj): "))
    print(f"Sum: {z1 + z2}")
    print(f"Difference: {z1 - z2}")
    print(f"Product: {z1 * z2}")
    print(f"Quotient: {z1 / z2}")

# Fonksiyon Grafikleme Fonksiyonu
def plot_function():
    x = sp.symbols('x')
    func_expr = input("Enter the function f(x) to plot: ")
    func = sp.sympify(func_expr)
    f = sp.lambdify(x, func, modules=['numpy'])
    x_vals = np.linspace(-10, 10, 400)
    y_vals = f(x_vals)
    plt.plot(x_vals, y_vals)
    plt.title(f'Plot of {func_expr}')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.grid(True)
    plt.show()

# Rasgele Sayı Üretimi Fonksiyonu
def random_number_generation():
    dist = input("Enter the distribution (uniform/normal): ")
    n = int(input("Enter the number of random numbers to generate: "))
    if dist == "uniform":
        low = float(input("Enter the lower bound: "))
        high = float(input("Enter the upper bound: "))
        random_numbers = np.random.uniform(low, high, n)
    elif dist == "normal":
        mean = float(input("Enter the mean: "))
        std_dev = float(input("Enter the standard deviation: "))
        random_numbers = np.random.normal(mean, std_dev, n)
    else:
        print("Invalid distribution.")
        return
    print(f"Generated random numbers: {random_numbers}")


# Fourier ve Laplace Dönüşümleri Fonksiyonu
def fourier_laplace_transforms():
    x = sp.symbols('x')
    t = sp.symbols('t', real=True)
    func_expr = input("Enter the function f(t) for Fourier and Laplace transforms: ")
    func = sp.sympify(func_expr)

    fourier_transform = sp.fourier_transform(func, t, x)
    laplace_transform = sp.laplace_transform(func, t, x)

    print(f"Fourier Transform: {sp.pretty(fourier_transform)}")
    print(f"Laplace Transform: {sp.pretty(laplace_transform[0])}")


# Finansal Hesaplamalar Fonksiyonu
def financial_calculations():
    print("\nChoose a financial calculation to perform:")
    print("1: Simple Interest")
    print("2: Compound Interest")
    choice = input("Enter your choice: ")

    if choice == '1':
        principal = float(input("Enter the principal amount: "))
        rate = float(input("Enter the annual interest rate (in %): "))
        time = float(input("Enter the time (in years): "))
        simple_interest = (principal * rate * time) / 100
        print(f"Simple Interest: {simple_interest}")

    elif choice == '2':
        principal = float(input("Enter the principal amount: "))
        rate = float(input("Enter the annual interest rate (in %): "))
        time = float(input("Enter the time (in years): "))
        n = int(input("Enter the number of times interest applied per year: "))
        compound_interest = principal * (1 + rate / (n * 100)) ** (n * time)
        print(f"Compound Interest: {compound_interest}")

    else:
        print("Invalid choice.")


# Graf Teorisi Fonksiyonu
def graph_theory():
    import networkx as nx
    G = nx.Graph()
    n = int(input("Enter the number of nodes: "))
    print("Enter the edges (format: node1 node2): ")
    for _ in range(n):
        u, v = map(int, input().split())
        G.add_edge(u, v)

    nx.draw(G, with_labels=True)
    plt.show()


# Kriptografi Fonksiyonu
def cryptography():
    print("\nChoose a cryptographic function:")
    print("1: Caesar Cipher")
    print("2: RSA Encryption")
    choice = input("Enter your choice: ")

    if choice == '1':
        text = input("Enter the text to encrypt: ")
        shift = int(input("Enter the shift value: "))
        encrypted = ''.join([chr((ord(char) + shift - 97) % 26 + 97) if char.islower() else char for char in text])
        print(f"Encrypted Text: {encrypted}")

    elif choice == '2':
        import rsa
        (pubkey, privkey) = rsa.newkeys(512)
        message = input("Enter the message to encrypt: ").encode('utf8')
        encrypted = rsa.encrypt(message, pubkey)
        print(f"Encrypted Message: {encrypted}")
        decrypted = rsa.decrypt(encrypted, privkey).decode('utf8')
        print(f"Decrypted Message: {decrypted}")

    else:
        print("Invalid choice.")


# Birim Dönüşümleri Fonksiyonu
def unit_conversion():
    print("\nChoose a unit conversion:")
    print("1: Length")
    print("2: Mass")
    print("3: Volume")
    choice = input("Enter your choice: ")

    if choice == '1':
        value = float(input("Enter the length in meters: "))
        print(f"{value} meters is {value * 100} centimeters")
        print(f"{value} meters is {value / 1000} kilometers")

    elif choice == '2':
        value = float(input("Enter the mass in kilograms: "))
        print(f"{value} kilograms is {value * 1000} grams")
        print(f"{value} kilograms is {value / 1000} metric tons")

    elif choice == '3':
        value = float(input("Enter the volume in liters: "))
        print(f"{value} liters is {value * 1000} milliliters")
        print(f"{value} liters is {value / 1000} cubic meters")

    else:
        print("Invalid choice.")


# Olasılık Hesaplamaları Fonksiyonu
def probability_calculations():
    print("\nChoose a probability calculation:")
    print("1: Binomial Probability")
    print("2: Normal Distribution Probability")
    choice = input("Enter your choice: ")

    if choice == '1':
        n = int(input("Enter the number of trials: "))
        p = float(input("Enter the probability of success: "))
        k = int(input("Enter the number of successes: "))
        binom_prob = sp.binomial(n, k) * (p ** k) * ((1 - p) ** (n - k))
        print(f"Binomial Probability: {binom_prob}")

    elif choice == '2':
        mean = float(input("Enter the mean: "))
        std_dev = float(input("Enter the standard deviation: "))
        x = float(input("Enter the value: "))
        normal_prob = (1 / (std_dev * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mean) / std_dev) ** 2)
        print(f"Normal Distribution Probability: {normal_prob}")

    else:
        print("Invalid choice.")
# Program Seçim Fonksiyonu
def choose_program():
    print("\nChoose a program to run:")
    print("1: Numeric Integration")
    print("2: Symbolic Integration")
    print("3: Prime Numbers within Range")
    print("4: Twin Prime Numbers within Range")
    print("5: Solve N-Variable Linear Equations")
    print("6: Matrix Multiplication")
    print("7: High Precision Power Calculation")
    print("8: Root Finding")
    print("9: Statistical Analysis")
    print("10: Curve Fitting")
    print("11: Solve Differential Equations")
    print("12: Matrix Operations")
    print("13: Complex Number Operations")
    print("14: Plot Functions")
    print("15: Random Number Generation")
    print("16: Fourier and Laplace Transforms")
    print("17: Financial Calculations")
    print("18: Graph Theory")
    print("19: Cryptography")
    print("20: Unit Conversions")
    print("21: Probability Calculations")
    print("22: Exit")
    choice = input("Enter your choice: ")
    return choice

# Ana Program Döngüsü
def solve_linear_equations():
    pass


def matrix_multiplication():
    pass


def main():
    while True:
        choice = choose_program()

        if choice.isdigit():
            choice = int(choice)
        else:
            print("Invalid input. Please enter a number.")
            continue

        if choice == 1:
            numerical_integral()

        elif choice == 2:
            symbolic_integral()

        elif choice == 3:
            find_primes()

        elif choice == 4:
            find_twin_primes()

        elif choice == 5:
            solve_linear_equations()

        elif choice == 6:
            matrix_multiplication()

        elif choice == 7:
            high_precision_power()

        elif choice == 8:
            root_finding()

        elif choice == 9:
            statistical_analysis()

        elif choice == 10:
            curve_fitting()

        elif choice == 11:
            solve_differential_equation()

        elif choice == 12:
            matrix_operations()

        elif choice == 13:
            complex_number_operations()

        elif choice == 14:
            plot_function()

        elif choice == 15:
            random_number_generation()

        elif choice == 16:
            fourier_laplace_transforms()

        elif choice == 17:
            financial_calculations()

        elif choice == 18:
            graph_theory()

        elif choice == 19:
            cryptography()

        elif choice == 20:
            unit_conversion()

        elif choice == 21:
            probability_calculations()

        elif choice == 22:
            print("Exiting the program.")
            break

        else:
            print("Invalid choice. Please select a valid program number.")

if __name__ == "__main__":
    main()