Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 24*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 24*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.83 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 27*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 27*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.44 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 49*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 49*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.57 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 50*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 50*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.89 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 49*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 49*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.87 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 6*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 6*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.77 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 25*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 25*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.89 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 19*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 19*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.38 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 17*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 17*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.95 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 22*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 22*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.91 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 40*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 40*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.58 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 40*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 40*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.69 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 5*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 5*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.54 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 47*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 47*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.8 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 8*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 8*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.85 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 4*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 4*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 40*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 40*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 28*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 28*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.65 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 21*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 21*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.05 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 34*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 34*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 5.83 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 16*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 16*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.51 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 42*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 42*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 38*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 38*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.54 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 9*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 9*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.34 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 47*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 47*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.43 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 11*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 11*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.11 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 6*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 6*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 29*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 29*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.7 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 21*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 21*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.22 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 4*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 4*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.52 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 24*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 24*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 32*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 32*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.57 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 20*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 20*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.16 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 24*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 24*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.31 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 40*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 40*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.63 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 28*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 28*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.37 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 5*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 5*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.58 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 34*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 34*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.62 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 37*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 37*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.48 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 22*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 22*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.25 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 12*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 12*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.82 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 39*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 39*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.56 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 23*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 23*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.77 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 26*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 26*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.55 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 16*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 16*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 11*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 11*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.11 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 7*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 7*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.94 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 20*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 20*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 9*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 9*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.95 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 6*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 6*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.61 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 14*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 14*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.32 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 28*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 28*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.74 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 16*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 16*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.33 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 28*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 28*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.74 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 39*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 39*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 6.24 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 45*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 45*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.12 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 13*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 13*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.81 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 13*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 13*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.96 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 33*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 33*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.32 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 41*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 41*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.55 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 30*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 30*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.24 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 20*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 20*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 38*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 38*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.36 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 29*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 29*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.41 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 38*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 38*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 15*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 15*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.73 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 18*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 18*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.22 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 38*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 38*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.36 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 36*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 36*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.81 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 44*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 44*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.69 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 47*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 47*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.42 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 37*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 37*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.4 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 33*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 33*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.57 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 24*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 24*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 19*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 19*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.52 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 5*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 5*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.79 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 4*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 4*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 40*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 40*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.69 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 23*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 23*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.52 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 5*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 5*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.71 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 24*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 24*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.46 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 44*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 44*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.35 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 48*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 48*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 7*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 7*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.18 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 36*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 36*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.6 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 22*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 22*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.66 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 41*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 41*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.85 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 31*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 31*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.86 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 43*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 43*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.07 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 46*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 46*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.03 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 13*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 13*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.61 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 32*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 32*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.3 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 5*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 5*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.56 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 40*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 40*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.91 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 21*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 21*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.29 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 13*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 13*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.93 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 6*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 6*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.82 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 8*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 8*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.41 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 3*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 3*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.46 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 26*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 26*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.93 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 4*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 4*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.76 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 4*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 4*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.67 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 35*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 35*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.42 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 1*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 1*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.23 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 1*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 1*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.33 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 18*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 18*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.06 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 7*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 7*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.53 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 19*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 19*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.52 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 39*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 39*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.61 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 28*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 28*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.18 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 24*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 24*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.9 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 18*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 18*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.5 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 27*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 27*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.96 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 19*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 19*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.52 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 44*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 44*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 6.63 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 22*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 22*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.25 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 31*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 31*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.97 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 17*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 17*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.06 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 42*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 42*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.49 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 18*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 18*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.73 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 21*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 21*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.08 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 44*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 44*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.84 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 28*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 28*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.65 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 36*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 36*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.66 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 5*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 5*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.56 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 20*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 20*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.16 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 12*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 12*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.22 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 11*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 11*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.35 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 1*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 1*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 49*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 49*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.5 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 11*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 11*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.89 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 16*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 16*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.79 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 37*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 37*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 6.08 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 29*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 29*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.35 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 44*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 44*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.71 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 17*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 17*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.38 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 2*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 2*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 1*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 1*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.23 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 13*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 13*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.09 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 17*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 17*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.3 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 27*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 27*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.6 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 12*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 12*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.87 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 31*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 31*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.94 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 49*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 49*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.7 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 39*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 39*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.21 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 33*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 33*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.57 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 24*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 24*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.31 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 19*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 19*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.97 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 41*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 41*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.85 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 39*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 39*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 3*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 3*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.22 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 26*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 26*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.41 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 22*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 22*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.3 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 35*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 35*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.64 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 31*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 31*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.54 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 41*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 41*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.78 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 26*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 26*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.36 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 32*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 32*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.51 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 2*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 2*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.63 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 32*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 32*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.31 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 34*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 34*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.2 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 13*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 13*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.14 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 5*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 5*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.65 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 6*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 6*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.82 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 13*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 13*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.9 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 27*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 27*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.19 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 45*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 45*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.74 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 12*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 12*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.04 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 7*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 7*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.32 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 10*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 10*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.41 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 40*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 40*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 21*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 21*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 14*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 14*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.65 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 43*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 43*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.75 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 11*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 11*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.8 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 3*y'' + 42*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(3*y(t).diff(t, 2) + 42*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.74 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 1*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 1*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.23 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 12*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 12*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.73 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 5*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 5*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 20*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 20*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.58 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 21*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 21*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.45 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 21*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 21*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.05 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 16*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 16*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.63 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 21*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 21*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.32 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 8*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 8*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.85 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 44*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 44*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.84 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 37*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 37*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.3 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 47*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 47*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.85 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 3*y' + 5*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 3*y(t).diff(t) + 5*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.4 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 35*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 35*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 5.92 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 7*y'' + 48*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(7*y(t).diff(t, 2) + 48*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.62 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 17*y'' + 6*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(17*y(t).diff(t, 2) + 6*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.59 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 3*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 3*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.71 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 18*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 18*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 16*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 16*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.33 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 26*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 26*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.17 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 17*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 17*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.68 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 23*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 23*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.24 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 31*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 31*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 3.94 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 9*y'' + 4*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(9*y(t).diff(t, 2) + 4*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.67 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 8*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 8*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.89 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 19*y'' + 48*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(19*y(t).diff(t, 2) + 48*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.59 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 4*y'' + 9*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(4*y(t).diff(t, 2) + 9*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.5 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 20*y'' + 12*y' + 1*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(20*y(t).diff(t, 2) + 12*y(t).diff(t) + 1*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 0.77 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 2*y'' + 40*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(2*y(t).diff(t, 2) + 40*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 4.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 36*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 36*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.55 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 46*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 46*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.81 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 1*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 1*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 5*y'' + 42*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(5*y(t).diff(t, 2) + 42*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.9 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 16*y'' + 29*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(16*y(t).diff(t, 2) + 29*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.35 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 38*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 38*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.86 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 14*y'' + 22*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(14*y(t).diff(t, 2) + 22*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.25 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 12*y'' + 50*y' + 8*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(12*y(t).diff(t, 2) + 50*y(t).diff(t) + 8*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.04 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 23*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 23*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.7 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 18*y'' + 23*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(18*y(t).diff(t, 2) + 23*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.13 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 1*y'' + 1*y' + 2*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(1*y(t).diff(t, 2) + 1*y(t).diff(t) + 2*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.0 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 13*y'' + 40*y' + 4*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(13*y(t).diff(t, 2) + 40*y(t).diff(t) + 4*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.75 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 8*y'' + 47*y' + 9*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(8*y(t).diff(t, 2) + 47*y(t).diff(t) + 9*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 2.42 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 15*y'' + 42*y' + 7*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(15*y(t).diff(t, 2) + 42*y(t).diff(t) + 7*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.67 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 6*y'' + 13*y' + 6*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(6*y(t).diff(t, 2) + 13*y(t).diff(t) + 6*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.47 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 11*y'' + 39*y' + 10*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(11*y(t).diff(t, 2) + 39*y(t).diff(t) + 10*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.88 rad/s


Instruction: Resoudre l equation differentielle d un oscillateur amorti 10*y'' + 23*y' + 3*y = 0 avec SymPy.

Output:
import sympy as sp
t = sp.Symbol('t', real=True, positive=True)
y = sp.Function('y')
eq = sp.Eq(10*y(t).diff(t, 2) + 23*y(t).diff(t) + 3*y(t), 0)
sol = sp.dsolve(eq, y(t))
print(f"Solution analytique: {sol}")
# Frequence propre quasi-harmonique: omega0 = 1.52 rad/s


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=72 Ohm, L=3 mH, C=145 uF.

Output:
import numpy as np

R = 72
L = 3e-3
C = 145e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 241.31 Hz, Q = 0.06


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=6 Ohm, L=11 mH, C=299 uF.

Output:
import numpy as np

R = 6
L = 11e-3
C = 299e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 87.76 Hz, Q = 1.01


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=90 Ohm, L=11 mH, C=348 uF.

Output:
import numpy as np

R = 90
L = 11e-3
C = 348e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 81.35 Hz, Q = 0.06


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=112 Ohm, L=72 mH, C=419 uF.

Output:
import numpy as np

R = 112
L = 72e-3
C = 419e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 28.98 Hz, Q = 0.12


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=118 Ohm, L=73 mH, C=197 uF.

Output:
import numpy as np

R = 118
L = 73e-3
C = 197e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 41.97 Hz, Q = 0.16


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=101 Ohm, L=17 mH, C=421 uF.

Output:
import numpy as np

R = 101
L = 17e-3
C = 421e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 59.49 Hz, Q = 0.06


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=76 Ohm, L=38 mH, C=136 uF.

Output:
import numpy as np

R = 76
L = 38e-3
C = 136e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 70.01 Hz, Q = 0.22


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=60 Ohm, L=50 mH, C=268 uF.

Output:
import numpy as np

R = 60
L = 50e-3
C = 268e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 43.48 Hz, Q = 0.23


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=6 Ohm, L=18 mH, C=388 uF.

Output:
import numpy as np

R = 6
L = 18e-3
C = 388e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 60.22 Hz, Q = 1.14


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=52 Ohm, L=56 mH, C=402 uF.

Output:
import numpy as np

R = 52
L = 56e-3
C = 402e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 33.54 Hz, Q = 0.23


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=172 Ohm, L=25 mH, C=65 uF.

Output:
import numpy as np

R = 172
L = 25e-3
C = 65e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 124.85 Hz, Q = 0.11


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=62 Ohm, L=6 mH, C=337 uF.

Output:
import numpy as np

R = 62
L = 6e-3
C = 337e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 111.93 Hz, Q = 0.07


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=130 Ohm, L=58 mH, C=56 uF.

Output:
import numpy as np

R = 130
L = 58e-3
C = 56e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 88.31 Hz, Q = 0.25


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=176 Ohm, L=28 mH, C=492 uF.

Output:
import numpy as np

R = 176
L = 28e-3
C = 492e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 42.88 Hz, Q = 0.04


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=196 Ohm, L=82 mH, C=347 uF.

Output:
import numpy as np

R = 196
L = 82e-3
C = 347e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 29.84 Hz, Q = 0.08


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=149 Ohm, L=78 mH, C=122 uF.

Output:
import numpy as np

R = 149
L = 78e-3
C = 122e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 51.59 Hz, Q = 0.17


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=153 Ohm, L=82 mH, C=344 uF.

Output:
import numpy as np

R = 153
L = 82e-3
C = 344e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 29.97 Hz, Q = 0.1


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=169 Ohm, L=39 mH, C=425 uF.

Output:
import numpy as np

R = 169
L = 39e-3
C = 425e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 39.09 Hz, Q = 0.06


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=144 Ohm, L=27 mH, C=107 uF.

Output:
import numpy as np

R = 144
L = 27e-3
C = 107e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 93.64 Hz, Q = 0.11


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=40 Ohm, L=54 mH, C=178 uF.

Output:
import numpy as np

R = 40
L = 54e-3
C = 178e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 51.33 Hz, Q = 0.44


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=65 Ohm, L=25 mH, C=216 uF.

Output:
import numpy as np

R = 65
L = 25e-3
C = 216e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 68.49 Hz, Q = 0.17


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=159 Ohm, L=90 mH, C=261 uF.

Output:
import numpy as np

R = 159
L = 90e-3
C = 261e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 32.84 Hz, Q = 0.12


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=124 Ohm, L=73 mH, C=46 uF.

Output:
import numpy as np

R = 124
L = 73e-3
C = 46e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 86.85 Hz, Q = 0.32


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=22 Ohm, L=49 mH, C=302 uF.

Output:
import numpy as np

R = 22
L = 49e-3
C = 302e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 41.37 Hz, Q = 0.58


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=43 Ohm, L=25 mH, C=95 uF.

Output:
import numpy as np

R = 43
L = 25e-3
C = 95e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 103.27 Hz, Q = 0.38


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=96 Ohm, L=45 mH, C=423 uF.

Output:
import numpy as np

R = 96
L = 45e-3
C = 423e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 36.48 Hz, Q = 0.11


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=48 Ohm, L=75 mH, C=254 uF.

Output:
import numpy as np

R = 48
L = 75e-3
C = 254e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 36.46 Hz, Q = 0.36


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=51 Ohm, L=19 mH, C=143 uF.

Output:
import numpy as np

R = 51
L = 19e-3
C = 143e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 96.56 Hz, Q = 0.23


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=98 Ohm, L=52 mH, C=279 uF.

Output:
import numpy as np

R = 98
L = 52e-3
C = 279e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 41.78 Hz, Q = 0.14


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=73 Ohm, L=22 mH, C=146 uF.

Output:
import numpy as np

R = 73
L = 22e-3
C = 146e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 88.8 Hz, Q = 0.17


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=125 Ohm, L=97 mH, C=267 uF.

Output:
import numpy as np

R = 125
L = 97e-3
C = 267e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 31.27 Hz, Q = 0.15


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=167 Ohm, L=62 mH, C=439 uF.

Output:
import numpy as np

R = 167
L = 62e-3
C = 439e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 30.51 Hz, Q = 0.07


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=176 Ohm, L=78 mH, C=148 uF.

Output:
import numpy as np

R = 176
L = 78e-3
C = 148e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 46.84 Hz, Q = 0.13


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=21 Ohm, L=33 mH, C=439 uF.

Output:
import numpy as np

R = 21
L = 33e-3
C = 439e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 41.81 Hz, Q = 0.41


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=16 Ohm, L=15 mH, C=30 uF.

Output:
import numpy as np

R = 16
L = 15e-3
C = 30e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 237.25 Hz, Q = 1.4


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=47 Ohm, L=37 mH, C=325 uF.

Output:
import numpy as np

R = 47
L = 37e-3
C = 325e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 45.9 Hz, Q = 0.23


Instruction: Calculer la frequence de resonance f0 et le facteur de qualite Q d un circuit RLC serie avec R=169 Ohm, L=61 mH, C=42 uF.

Output:
import numpy as np

R = 169
L = 61e-3
C = 42e-6

f0 = 1 / (2 * np.pi * np.sqrt(L * C))
Q = (1 / R) * np.sqrt(L / C)

print(f"Fréquence de résonance f0: {f0:.2f} Hz")
print(f"Facteur de qualité Q: {Q:.2f}")
# f0 calcule = 99.43 Hz, Q = 0.23