1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
# Solving non-linear equations
## Introduction
## Prerequisites
```python
import numpy
import scipy
import sympy
```
## fsolve from SciPy
```python
from scipy.optimize import fsolve
def equations(vars):
x, y = vars
eq1 = x**2 + y**2 - 25
eq2 = x**2 - y
return [eq1, eq2]
initial_guess = [1, 1]
solution = fsolve(equations, initial_guess)
print("Solution:", solution)
```
## root from SciPy
```python
from scipy.optimize import root
def equations(vars):
x, y = vars
eq1 = x**2 + y**2 - 25
eq2 = x**2 - y
return [eq1, eq2]
initial_guess = [1, 1]
solution = root(equations, initial_guess)
print("Solution:", solution.x)
```
## minimize from SciPy
```python
from scipy.optimize import minimize
# Define the equations
def equation1(x, y):
return x**2 + y**2 - 25
def equation2(x, y):
return x**2 - y
# Define the objective function for optimization
def objective(xy):
x, y = xy
return equation1(x, y)**2 + equation2(x, y)**2
# Initial guess
initial_guess = [1, 1]
# Perform optimization
result = minimize(objective, initial_guess)
solution_optimization = result.x
print("Optimization Method Solution:", solution_optimization)
```
## nsolve from SymPy
```python
from sympy import symbols, Eq, nsolve
# Define the variables
x, y = symbols('x y')
# Define the equations
eq1 = Eq(x**2 + y**2, 25)
eq2 = Eq(x - y, 0)
# Initial guess for the solution
initial_guess = [1, 1]
# Use nsolve to find the solution
solution = nsolve([eq1, eq2], [x, y], initial_guess)
print("Solution:", solution)
```
## newton_method from NumPy
```python
import numpy as np
def equations(vars):
x, y = vars
eq1 = x**2 + y**2 - 25
eq2 = x**2 - y
return np.array([eq1, eq2])
def newton_method(initial_guess, tolerance=1e-6, max_iter=100):
vars = np.array(initial_guess, dtype=float)
for _ in range(max_iter):
J = np.array([[2 * vars[0], 2 * vars[1]], [2 * vars[0], -1]])
F = equations(vars)
delta = np.linalg.solve(J, -F)
vars += delta
if np.linalg.norm(delta) < tolerance:
return vars
initial_guess = [1, 1]
solution = newton_method(initial_guess)
print("Solution:", solution)
```
|
