Liczby zespolone

from IPython.display import display, Markdown
import sympy as sp

a, b = sp.symbols('a b', real=True)
r, phi = sp.symbols('r \phi')

var = {a:3, b: 4}

# Definicja liczby zespolonej
z = a + sp.I * b

zv = z.subs(var)

# Moduł i argument
argument = sp.arg(zv)
modul = abs(zv)

# Postać trygonometryczna
z_trigon = r * (sp.cos(phi) + sp.I * sp.sin(phi))

# Postać wykładnicza
z_exp = r  * sp.exp(sp.I * phi)

# wyświetlenie wyników
latex_code = fr"""
\begin{{align*}}
& \Large  Re(z)=a={sp.latex(var[a])}; \; Im(z)=b={sp.latex(var[b])}  \\
& \Large  z={sp.latex(z)}={sp.latex(zv)}; \; \text{{postać algebraiczna}}  \\
& \Large  \overline z={sp.latex(sp.conjugate(z))}={sp.latex(sp.conjugate(zv))}; \; \text{{sprzężona}}  \\
& \Large  |z|={sp.latex(r)}={sp.latex(abs(z))}={sp.latex(modul)}; \; \text{{muduł liczby}}  \\
& \Large  z={sp.latex(phi)}={sp.latex(sp.arg(z))}={sp.latex(argument)};  \; \text{{argument liczby}}  \\
& \Large  z_t={sp.latex(z_trigon)}; \; \text{{postać trygonometryczna}}  \\
& \Large  z_w={sp.latex(z_exp)}; \; \text{{postać wykładnicza}}  \\
\end{{align*}}
"""

display(Markdown(latex_code))

\begin{align*} & \Large Re(z)=a=3; \; Im(z)=b=4 \\ & \Large z=a + i b=3 + 4 i; \; \text{postać algebraiczna} \\ & \Large \overline z=a - i b=3 - 4 i; \; \text{sprzężona} \\ & \Large |z|=r=\sqrt{a^{2} + b^{2}}=5; \; \text{muduł liczby} \\ & \Large z=\phi=\arg{\left(a + i b \right)}=\operatorname{atan}{\left(\frac{4}{3} \right)}; \; \text{argument liczby} \\ & \Large z_t=r \left(i \sin{\left(\phi \right)} + \cos{\left(\phi \right)}\right); \; \text{postać trygonometryczna} \\ & \Large z_w=r e^{i \phi}; \; \text{postać wykładnicza} \\ \end{align*}

import sympy as sp
import plotly.graph_objects as go
import plotly as pl
pl.io.renderers.default = "notebook_connected" # musi być jeżeli chcemy do html-a

def init_fig(x_min=-5, x_max=5, y_min = -5, y_max = 5):
    global fig
    # Tworzenie wykresu w Plotly
    fig = go.Figure()
    # Dodanie osi
    fig.add_trace(go.Scatter(
        x=[x_min, x_max],  # Oś rzeczywista
        y=[0, 0],
        mode='lines',
        line=dict(color='black', width=2),
        name="Oś rzeczywista"
    ))

    fig.add_trace(go.Scatter(
        x=[0, 0],  # Oś urojona
        y=[y_min, y_max],
        mode='lines',
        line=dict(color='black', width=2),
        name="Oś urojona"
    ))
    # Konfiguracja układu wykresu
    fig.update_layout(
    title="Liczby zespolone na płaszczyźnie",
    xaxis_title="Re",
    yaxis_title="Im",
    xaxis=dict(showgrid=True, zeroline=True, scaleanchor="y", scaleratio=1),
    yaxis=dict(showgrid=True, zeroline=True),
    showlegend=False
    )

def add_complex(complex,lab):
    global fig

    # Rozdziel część rzeczywistą i urojoną, konwertując na float
    real_parts = [float(sp.re(z_)) for z_ in complex]
    imaginary_parts = [float(sp.im(z_)) for z_ in complex]

    # Dodanie punktów reprezentujących liczby zespolone
    fig.add_trace(go.Scatter(
        x=real_parts, 
        y=imaginary_parts, 
        mode='markers+text',
        text=[f'{lab[z]}={z}' for z in complex],  # Dodanie etykiet liczb zespolonych
        textposition='top center',
        marker=dict(size=10, color='blue')
    ))


# Definiowanie liczb zespolonych za pomocą SymPy
z1 = zv
z2 = sp.conjugate(zv)
z3 = sp.I 

init_fig()
add_complex(complex=[z1,z2,z3], lab = {z1: 'z1', z2: 'z2', z3: 'z3'})

# Wyświetlenie wykresu
fig.show()

from IPython.display import display, Markdown
import sympy as sp

a1, b1 = sp.symbols('a_1 b_1', real=True)
a2, b2 = sp.symbols('a_2 b_2', real=True)

# Definicja liczby zespolonej
z1 = a1 + sp.I * b1
z2 = a2 + sp.I * b2
sum = sp.collect(z1+z2, sp.I)
ilo = sp.collect(sp.expand(z1*z2), sp.I)

# wyświetlenie wyników
latex_code = fr"""
\begin{{align*}}
& \Large  z_1={sp.latex(z1)}; z_2={sp.latex(z2)} \\
& \Large  z_1+z_2={sp.latex(sum)} \\
& \Large  z_1*z_2={sp.latex(ilo)}
\end{{align*}}
"""

display(Markdown(latex_code))

\begin{align*} & \Large z_1=a_{1} + i b_{1}; z_2=a_{2} + i b_{2} \\ & \Large z_1+z_2=a_{1} + a_{2} + i \left(b_{1} + b_{2}\right) \\ & \Large z_1*z_2=a_{1} a_{2} - b_{1} b_{2} + i \left(a_{1} b_{2} + a_{2} b_{1}\right) \end{align*}

var = {a1:1, b1: 1,
       a2:2, b2: -2}

z1 = z1.subs(var)
z2 = z2.subs(var)
sum = sum.subs(var)
ilo = ilo.subs(var)

init_fig()
add_complex(complex=[z1,z2,sum,ilo], lab = {z1:'z1',  z2: 'z2', sum: 'z1+z2', ilo: 'z1*z2'})

# Wyświetlenie wykresu
fig.show()

Pierwiastki liczby zespolonej

from IPython.display import display, Markdown
import sympy as sp

# Definicja liczby zespolonej
z = sp.Symbol('z')
complex_number = 1 + sp.I  # Przykładowa liczba zespolona

# Stopień pierwiastka
n = 3  # Pierwiastki 3 stopnia

# Obliczanie pierwiastków
roots = sp.roots(sp.Pow(z, n) - complex_number, z)


# Wyświetlenie wyników
latex_code = fr"""
\begin{{align*}}
    & \Large  z={sp.latex(complex_number)}; \; n={n} \\ \\
"""
for i, root in enumerate(roots):
    #root = sp.collect(root)
    root = sp.simplify(root)
    phi = sp.arg(root)
    r = abs(root)
    z_t = r * (sp.cos(phi) + sp.I * sp.sin(phi))
    latex_code += fr"""
    & \Large  z_{{{i+1}}}={sp.latex(root)} \\ \\
    """
latex_code += fr"""
\end{{align*}}
"""    

display(Markdown(latex_code))

\begin{align*} & \Large z=1 + i; \; n=3 \\ \\ & \Large z_{1}=\frac{2^{\frac{2}{3}} \left(1 - i\right) \left(1 + \sqrt{3} i\right)}{4} \\ \\ & \Large z_{2}=\frac{2^{\frac{2}{3}} \left(1 - i\right) \left(1 - \sqrt{3} i\right)}{4} \\ \\ & \Large z_{3}=\frac{2^{\frac{2}{3}} \left(-1 + i\right)}{2} \\ \\ \end{align*}

complex = []
lab = {}

for i, root in enumerate(roots):
    complex.append(root)
    lab.update({root : f'z{i+1}'})

print(f'{l=}')

init_fig(x_min=-2, x_max=2, y_min = -2, y_max = 2)
add_complex(complex=complex, lab = lab)

# Wyświetlenie wykresu
fig.show()

l={2**(2/3)/4 + 2**(2/3)*sqrt(3)/4 - 2**(2/3)*I/4 + 2**(2/3)*sqrt(3)*I/4: 'z1', -2**(2/3)*sqrt(3)/4 + 2**(2/3)/4 - 2**(2/3)*sqrt(3)*I/4 - 2**(2/3)*I/4: 'z2', -2**(2/3)/2 + 2**(2/3)*I/2: 'z3'}

import plotly.graph_objects as go
import numpy as np

fig = go.Figure()

for i, c in enumerate(complex):
    r = sp.Abs(c)
    r_v = float(r.evalf())  # Moduł liczby zespolonej
    theta = sp.arg(c)
    theta_v = float(theta.evalf())
    theta_d = float(sp.deg(theta))
    c_t = r * (sp.cos(theta) + sp.I * sp.sin(theta))
    c_t = c_t.collect(sp.I) #simplify() 
    fig.add_trace(go.Scatterpolar(
        r=[r_v],
        theta=[theta_d],
        mode='markers+text',
        marker=dict(size=12, color='red'),
        text=[f'z{i+1}'],
        textposition='top center'
    ))

# Ustawienia wykresu
fig.update_layout(
    title="Pierwiastki na wykresie polarno-biegunowym",
    polar=dict(
        radialaxis=dict(visible=True),
        angularaxis=dict(visible=True)
    ),
    showlegend=False
)

# Wyświetlenie wykresu
fig.show()

próby animacji

import plotly.graph_objects as go
import numpy as np

# Parametry liczby zespolonej
r = 1  # Moduł liczby zespolonej
theta_vals = np.linspace(0, 2*np.pi, 100)  # Zakres kątów (argumentów), 100 punktów

# Stworzenie wykresu
fig = go.Figure(
    data=[go.Scatterpolar(
        r=[r],
        theta=[0],  # Początkowy kąt
        mode='markers+text',
        marker=dict(size=12, color='red'),
        text=[f'Argument: {np.degrees(0):.2f}°\nRe: {r * np.cos(0):.2f}\nIm: {r * np.sin(0):.2f}'],
        textposition='top center'
    )],
    layout=go.Layout(
        title="Zmiana argumentu liczby zespolonej",
        polar=dict(
            radialaxis=dict(visible=True),
            angularaxis=dict(visible=True)
        ),
        showlegend=False
    )
)

# Animacja zmiany kąta
frames = [go.Frame(
    data=[go.Scatterpolar(
        r=[r],
        theta=[np.degrees(theta)],  # Zamiana na stopnie
        mode='markers+text',
        marker=dict(size=12, color='red'),
        # Obliczanie Re i Im
        text=[f'z={r * np.cos(theta):.2f}+{r * np.sin(theta):.2f}i'],
        textposition='top center'
    )],
    name=f"Frame {i}"
) for i, theta in enumerate(theta_vals)]

#text=[f'Arg: {np.degrees(theta):.2f}°\n z={r * np.cos(theta):.2f}+{r * np.sin(theta):.2f}i'],

# Dodanie frames do wykresu
fig.frames = frames

# Dodanie przycisków animacji
fig.update_layout(updatemenus=[dict(
    type="buttons",
    x=0.1,
    y=-0.1,
    buttons=[dict(
        label="Play",
        method="animate",
        args=[None, dict(frame=dict(duration=100, redraw=True), fromcurrent=True)]
    )]
)])

# Wyświetlenie wykresu
fig.show()