#the_numpy_array_
#size_shape_ndim_dtype
import numpy as np
#1_dtype
# Creating an array of integers with data type 'int16'
arrint16 = np.array([10, 20, 30], dtype=np.int16)
print(arrint16.dtype)
# Output: int16
# Creating an array of floats with data type 'float64'
arrfloat = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print(arrfloat.dtype)
# Output: float64
import numpy as np
#2_size
#Creating a 2D array and calculating its size
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr1.size)
# Output: 6
#Creating a 1D array and calculating its size
arr2 = np.array([10, 20, 30, 40, 50])
print(arr2.size)
# Output: 5
import numpy as np
#3_shape
#Creating a 3D array and checking its shape
arr3 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
print(arr3.shape)
# Output: (3, 2, 2)
#Creating a 1D array and checking its shape
arr4 = np.array([1, 2, 3, 4, 5])
print(arr4.shape)
# Output: (5,)
import numpy as np
#4_ndim
#Creating a 2D array and checking its number of dimensions
arr5 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr5.ndim)
# Output: 2
#Creating a 1D array and checking its number of dimensions
arr6 = np.array([10, 20, 30])
print(arr6.ndim)
# Output: 1
import numpy as np
#create_an_array_filled_with_zeros
arrzeros = np.zeros((2, 3))
print(arrzeros)
# Output:
# [[0. 0. 0.]
# [0. 0. 0.]]
import numpy as np
#array_filled_with_ones
arrones = np.ones((3, 2))
print(arrones)
# Output:
# [[1. 1.]
# [1. 1.]
# [1. 1.]]
import numpy as np
#array_filled_with_specified_value
arrfull = np.full((2, 2), 5)
print(arrfull)
# Output:
# [[5 5]
# [5 5]]
import numpy as np
#array_with_range_of_values
arrarange = np.arange(1, 10, 2)
print(arrarange)
# Output: [1 3 5 7 9]
import numpy as np
#array with evenly spaced value
arrlinspace = np.linspace(0, 10, 5)
print(arrlinspace)
# Output: [ 0. 2.5 5. 7.5 10. ]
import numpy as np
#array with values spaced evenly on a logarithmic scale
arrlogspace = np.logspace(1, 3, 4)
print(arrlogspace)
# Output: [ 10. 46.4 215.4 1000. ]
import numpy as np
#square identity matrix
arridentity = np.identity(3)
print(arridentity)
# Output:
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
import numpy as np
#2D array with ones in the diagonal
arreye = np.eye(3, 4)
print(arreye)
# Output:
# [[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]]
import numpy as np
#array into specific data type
arr = np.array([1, 2, 3])
arrnew = arr.astype(float)
print(arrnew)
# Output: [1. 2. 3.]
import numpy as np
import numpy as np
# Creating a sample array
arr = np.array([[1, 2, 3],
[4, 5,6],
[7, 8,9]])
# Indexing
print("Indexing:")
print(arr[0, 0])
print(arr[1])
print(arr[:, 1])
# Slicing
print("\nSlicing:")
print(arr[0:2, 1:])
#output:
#Indexing:
#[4 5 6]
#[2 5 8]
#Slicing:
#[[2 3]
# [5 6]]
#Important array methods
# Reshape
print("Reshape:")
print(arr.reshape(1, 9))
# Ravel
print("\nRavel:")
print(arr.ravel())
# Flatten
print("\nFlatten:")
print(arr.flatten())
# Hstack and Vstack
arr1 = np.array([[10, 11, 12]])
print("\nHstack:")
print(np.hstack((arr, arr1)))
arr2 = np.array([[13],
[14],
[15]])
print("\nVstack:")
print(np.vstack((arr, arr2)))
#output:
#Reshape:
[[1 2 3 4 5 6 7 8 9]]
#Ravel:
[1 2 3 4 5 6 7 8 9]
#Flatten:
[1 2 3 4 5 6 7 8 9]
#Hstack:
[[ 1 2 3 10 11 12]]
#Vstack:
[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[13 14 15]]
# Element-wise functions
print("\nElement-wise Functions:")
arr = np.array([[1, 2, 3],
[4, 5, 6]])
# Square each element
print(np.square(arr))
# Square root of each element
print(np.sqrt(arr))
# Using vectorize
vec_square = np.vectorize(lambda x: x ** 2)
print(vec_square(arr))
#output:
#Element-wise Functions:
[[ 1 4 9]
[16 25 36]]
[[1. 1.41421356 1.73205081]
[2. 2.23606798 2.44948974]]
[[ 1 4 9]
[16 25 36]]
#np.sum_
import numpy as np
arr = np.array([[1, 2], [3, 4]])
sumresult = np.sum(arr)
print(sumresult)
#output: 10
#np.prod(): Computes the product of array elements over a specified axis.
import numpy as np
arr = np.array([[1, 2], [3, 4]])
prodresult = np.prod(arr)
print(prodresult)
#output: 24
#np.mean(): Computes the arithmetic mean along the specified axis.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
meanresult = np.mean(arr)
print(meanresult)
#output: 3.0
#np.std(): Computes the standard deviation along the specified axis
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
stdresult = np.std(arr)
print(stdresult)
#output: 1.4142135623730951
#np.var(): Computes the variance along the specified axis.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
varresult = np.var(arr)
print(varresult)
#output: 2.0
#np.min(): Returns the minimum value along the specified axis.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
minresult = np.min(arr)
print(minresult)
#output: 1
#np.max(): Returns the maximum value along the specified axis.
import numpy as np
arr = np.array([1, 2, 3, 4, 5])
maxresult = np.max(arr)
print(maxresult)
#output:5
#np.argmin(): Returns the indices of the minimum values along the specified axis.
arr= np.array([1, 2, 3, 4, 5])
argminresult = np.argmin(arr)
print(argminresult)
#output: 0
#np.argmax(): Returns the indices of the maximum values along the specified axis.
arr = np.array([1, 2, 3, 4, 5])
argmaxresult = np.argmax(arr)
print(argmaxresult)
#output: 4
#addition_and_multiplication_dot_products
import numpy as np
# Create two matrices
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# Addition
C=A+B
print("Addition:")
print(C)
# Multiplication (Dot Product)
D = np.dot(A, B)
print("\nMultiplication (Dot Product):")
print(D)
#output:
#Addition:
[[ 6 8]
[10 12]]
#Multiplication (Dot Product):
[[19 22]
[43 50]]
#Gauss elimination (with partial pivoting)_
import numpy as np
# Create a matrix
A = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Using NumPy's linalg module to calculate the determinant
det_A = np.linalg.det(A)
print("Determinant of A:")
print(det_A)
#output:
#Determinant of A: 0.0
#solving linear equations_
import numpy as np
# Coefficients matrix
A = np.array([[2, 1], [1, -1]])
# Constants matrix
B = np.array([4, 1])
# Solve linear equations
solution = np.linalg.solve(A, B)
print("Solution:")
print(solution)
#output:
#Solution: [3. 1.]
#using NumPy linalg module for solving equation_
import numpy as np
# Coefficients matrix
A = np.array([[2, 1], [1, -1]])
# Constants matrix
B = np.array([4, 1])
# Solve linear equations using linalg.solve
solution = np.linalg.solve(A, B)
print("Solution:")
print(solution)
#output:
# Solution:[3. 1.]
#Diagonalization
import numpy as np
# Create a matrix
A = np.array([[1, 2], [3, 4]])
# Diagonalize the matrix
eigenvalues, eigenvectors = np.linalg.eig(A)
print("Eigenvalues:")
print(eigenvalues)
print("\nEigenvectors:")
print(eigenvectors)
#output:
#Eigenvalues:
[-0.37228132 5.37228132]
#Eigenvectors:
[[-0.82456484 -0.41597356]
[0.56576746 -0.90937671]]
#INTERPOLATION USING NumPy and scipy.interpolate for visualization_
#1
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import lagrange, interp1d
# Sample data points
x = np.array([1, 2, 3, 4])
y = np.array([4, 2, 1, 3])
# Lagrange Interpolation
lag_poly = lagrange(x, y)
# Newton Forward Interpolation
newton_poly = interp1d(x, y, kind='linear')
# Generate more points for smooth curve
x_interp = np.linspace(min(x), max(x), 100)
y_interp_lag = lag_poly(x_interp)
y_interp_newton = newton_poly(x_interp)
# Plotting
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'o', label='Data Points')
plt.plot(x_interp, y_interp_lag, label='Lagrange Interpolation')
plt.plot(x_interp, y_interp_newton, label='Newton Forward Interpolation')
plt.title('Interpolation Methods Comparison')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
Output:
#2
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import lagrange, interp1d
# Sample data points
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 3, 2, 4, 6])
# Lagrange Interpolation
lag_poly = lagrange(x, y)
# Newton Forward Interpolation
newton_poly = interp1d(x, y, kind='linear')
# Generate more points for smooth curve
x_interp = np.linspace(min(x), max(x), 100)
y_interp_lag = lag_poly(x_interp)
y_interp_newton = newton_poly(x_interp)
# Plotting
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'o', label='Data Points')
plt.plot(x_interp, y_interp_lag, label='Lagrange Interpolation')
plt.plot(x_interp, y_interp_newton, label='Newton Forward Interpolation')
plt.title('Interpolation Methods Comparison')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
#output:
#with oscillating data points_
import numpy as np
import matplotlib.pyplot as plt
from scipy.interpolate import lagrange, interp1d
# Sample oscillating data points
x = np.linspace(0, 10, 20)
y = np.sin(x)
# Lagrange Interpolation
lag_poly = lagrange(x, y)
# Newton Forward Interpolation
newton_poly = interp1d(x, y, kind='linear')
# Generate more points for smooth curve
x_interp = np.linspace(min(x), max(x), 100)
y_interp_lag = lag_poly(x_interp)
y_interp_newton = newton_poly(x_interp)
# Plotting
plt.figure(figsize=(10, 6))
plt.plot(x, y, 'o', label='Data Points')
plt.plot(x_interp, y_interp_lag, label='Lagrange Interpolation')
plt.plot(x_interp, y_interp_newton, label='Newton Forward Interpolation')
plt.title('Interpolation Methods Comparison')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
#output:
#trapezoidal rule and Simpsons 1/3rd rule using both numpy and scipy
import numpy as np
from scipy.integrate import quad, trapz, simps
# Define a sample function
def func(x):
return np.sin(x)
# Define the interval
a=0
b = np.pi
# Number of sample points
n = 100
# Trapezoidal Rule using numpy
x = np.linspace(a, b, n)
y = func(x)
trapezoidal_result_numpy = np.trapz(y, x)
# Trapezoidal Rule using scipy
trapezoidal_result_scipy = trapz(y, x)
# Simpson's One-Third Rule using numpy
simpsons_result_numpy = np.sum(simps(y, x))
# Simpson's One-Third Rule using scipy
simpsons_result_scipy = simps(y, x)
# Numerical integration using quad function from scipy
quad_result, _ = quad(func, a, b)
print("Trapezoidal Rule (numpy):", trapezoidal_result_numpy)
print("Trapezoidal Rule (scipy):", trapezoidal_result_scipy)
print("Simpson's One-Third Rule (numpy):", simpsons_result_numpy)
print("Simpson's One-Third Rule (scipy):", simpsons_result_scipy)
print("Quad (scipy.integrate.quad()):", quad_result)
#output:
#Trapezoidal Rule (numpy): 1.9998321638939929
#Trapezoidal Rule (scipy): 1.9998321638939929
#Simpson's One-Third Rule (numpy): 1.9999999690165369
#Simpson's One-Third Rule (scipy): 1.9999999690165369
#Quad (scipy.integrate.quad()): 2.0
#integrating the function [f(x) = x³-2x²+x+1] over the interval ([0, 2])
import numpy as np
# Define the function
def func(x):
return x**3 - 2*x**2 + x + 1
# Define the interval
a=0
b=2
# Number of sample points
n = 1000
# Trapezoidal Rule
x_trap = np.linspace(a, b, n)
y_trap = func(x_trap)
trapezoidal_result = np.trapz(y_trap, x_trap)
# Simpson's One-Third Rule
x_simpson = np.linspace(a, b, n+1)
y_simpson = func(x_simpson)
h = (b - a) / n
simpsons_result = h/3 * (y_simpson[0] + y_simpson[-1] + 4*np.sum(y_simpson[1:-1:2]) +
2*np.sum(y_simpson[2:-1:2]))
print("Trapezoidal Rule:", trapezoidal_result)
print("Simpson's One-Third Rule:", simpsons_result)
#output:
#Trapezoidal Rule: 4.666666666666667
#Simpson's One-Third Rule: 4.666666666666667
#solution of ODE
import numpy as np
# Define the RK4 algorithm for first-order ODE
def rk4_first_order(func, y0, x_range, h):
n = len(x_range)
y = np.zeros(n)
y[0] = y0
for i in range(1, n):
k1 = h * func(x_range[i-1], y[i-1])
k2 = h * func(x_range[i-1] + 0.5 * h, y[i-1] + 0.5 * k1)
k3 = h * func(x_range[i-1] + 0.5 * h, y[i-1] + 0.5 * k2)
k4 = h * func(x_range[i-1] + h, y[i-1] + k3)
y[i] = y[i-1] + (k1 + 2*k2 + 2*k3 + k4) / 6
return y
# Define the RK4 algorithm for second-order ODE
def rk4_second_order(func, y0, dy0, x_range, h):
n = len(x_range)
y = np.zeros(n)
dy = np.zeros(n)
y[0] = y0
dy[0] = dy0
for i in range(1, n):
k1 = h * dy[i-1]
l1 = h * func(x_range[i-1], y[i-1], dy[i-1])
k2 = h * (dy[i-1] + 0.5 * l1)
l2 = h * func(x_range[i-1] + 0.5 * h, y[i-1] + 0.5 * k1, dy[i-1] + 0.5 * l1)
k3 = h * (dy[i-1] + 0.5 * l2)
l3 = h * func(x_range[i-1] + 0.5 * h, y[i-1] + 0.5 * k2, dy[i-1] + 0.5 * l2)
k4 = h * (dy[i-1] + l3)
l4 = h * func(x_range[i-1] + h, y[i-1] + k3, dy[i-1] + l3)
y[i] = y[i-1] + (k1 + 2*k2 + 2*k3 + k4) / 6
dy[i] = dy[i-1] + (l1 + 2*l2 + 2*l3 + l4) / 6
return y, dy
# Example: Solve the first-order ODE dy/dx = -2y
def func_first_order(x, y):
return -2 * y
# Example: Solve the second-order ODE d^2y/dx^2 = -y with initial conditions y(0) = 0, dy(0)/dx = 1
def func_second_order(x, y, dy):
return -y
# Define the range and step size
x_range = np.linspace(0, 2, 101)
h = x_range[1] - x_range[0]
# Solve the first-order ODE using RK4
y0 = 1 # initial condition: y(0) = 1
y_solution_first_order = rk4_first_order(func_first_order, y0, x_range, h)
# Solve the second-order ODE using RK4
y0_second_order = 0 # initial condition: y(0) = 0
dy0_second_order = 1 # initial condition: dy/dx(0) = 1
y_solution_second_order, dy_solution_second_order = rk4_second_order(func_second_order, y0_second_order,
dy0_second_order, x_range, h)
print("First-order ODE Solution (RK4):", y_solution_first_order)
print("Second-order ODE Solution (RK4):", y_solution_second_order)
#output:
#First-order ODE Solution (RK4): [1. 0.96078944 0.92311635 0.88692044 0.85214379 0.81873076
0.78662787 0.75578375 0.72614904 0.69767633 0.67032005 0.64403643
0.6187834 0.59452055 0.57120907 0.54881164 0.52729243 0.506617
0.48675226 0.46766643 0.44932897 0.43171053 0.41478292 0.39851905
0.38289289 0.36787945 0.35345469 0.33959553 0.3262798 0.31348619
0.30119422 0.28938423 0.27803731 0.26713531 0.25666078 0.24659697
0.23692777 0.2276377 0.21871189 0.21013608 0.20189653 0.19398005
0.18637398 0.17906615 0.17204487 0.16529889 0.15881743 0.15259011
0.14660697 0.14085843 0.13533529 0.13002872 0.12493022 0.12003163
0.11532513 0.11080316 0.10645851 0.10228421 0.09827359 0.09442023
0.09071796 0.08716086 0.08374323 0.08045961 0.07730474 0.07427358
0.07136127 0.06856316 0.06587476 0.06329177 0.06081007 0.05842567
0.05613477 0.05393369 0.05181892 0.04978707 0.04783489 0.04595926
0.04415717 0.04242574 0.04076221 0.0391639 0.03762826 0.03615283
0.03473526 0.03337327 0.03206469 0.03080741 0.02959944 0.02843883
0.02732372 0.02625235 0.02522298 0.02423397 0.02328374 0.02237077
0.0214936 0.02065083 0.0198411 0.01906312 0.01831564]
#Second-order ODE Solution (RK4): [0. 0.01999867 0.03998933 0.05996401 0.07991469 0.09983342
0.11971221 0.13954311 0.15931821 0.17902957 0.19866933 0.21822962
0.23770263 0.25708055 0.27635565 0.29552021 0.31456656 0.33348709
0.35227423 0.37092047 0.38941834 0.40776045 0.42593946 0.44394811
0.46177917 0.47942554 0.49688014 0.51413599 0.5311862 0.54802394
0.56464247 0.58103516 0.59719544 0.61311685 0.62879302 0.64421769
0.65938467 0.67428791 0.68892144 0.70327942 0.71735609 0.73114583
0.74464312 0.75784256 0.77073888 0.78332691 0.79560162 0.8075581
0.81919157 0.83049737 0.84147098 0.85210802 0.86240423 0.87235548
0.88195781 0.89120736 0.90010044 0.9086335 0.91680311 0.92460601
0.93203909 0.93909936 0.945784 0.95209034 0.95801586 0.96355818
0.9687151 0.97348454 0.9778646 0.98185353 0.98544973 0.98865176
0.99145835 0.99386836 0.99588084 0.99749499 0.99871014 0.99952583
0.99994172 0.99995765 0.9995736 0.99878974 0.99760638 0.99602399
0.9940432 0.99166481 0.98888977 0.98571918 0.98215432 0.97819661
0.97384763 0.96910913 0.963983 0.95847128 0.95257619 0.94630009
0.93964547 0.93261501 0.92521152 0.91743796 0.90929743]
#CURVE FITTING
#examples of both the methods
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
# Sample data
x_data = np.array([1, 2, 3, 4, 5])
y_data = np.array([2.5, 3.5, 4.5, 5.5, 6.5])
# Curve fitting with numpy polynomials
degree = 2
coefficients = np.polyfit(x_data, y_data, degree)
poly_fit = np.poly1d(coefficients)
x_range = np.linspace(min(x_data), max(x_data), 100)
y_fit_poly = poly_fit(x_range)
# Curve fitting with user-defined function
def func(x, a, b):
return a * x + b
params, _ = curve_fit(func, x_data, y_data)
a_fit, b_fit = params
y_fit_custom = func(x_range, a_fit, b_fit)
# Plotting
plt.figure(figsize=(10, 6))
plt.scatter(x_data, y_data, label='Data Points')
plt.plot(x_range, y_fit_poly, label='Polynomial Fit (Numpy)')
plt.plot(x_range, y_fit_custom, label='Custom Function Fit (Scipy)')
plt.title('Curve Fitting Comparison')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
#output:
#2
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
# Generate sample data
np.random.seed(0)
x_data = np.linspace(0, 10, 100)
y_data = 2 * np.sin(x_data) + np.random.normal(0, 0.5, 100)
# Define a user-defined function for curve fitting
def func(x, a, b, c):
return a * np.sin(b * x + c)
# Perform curve fitting
params, _ = curve_fit(func, x_data, y_data, p0=[2, 1, 0])
# Generate fitted curve
y_fit = func(x_data, *params)
# Plotting
plt.figure(figsize=(10, 6))
plt.scatter(x_data, y_data, label='Data Points')
plt.plot(x_data, y_fit, color='red', label='Fitted Curve')
plt.title('Curve Fitting Example')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()
#output:
#matplotlib's pyplot submodule_
#figure, axes, subplot
import matplotlib.pyplot as plt
# Creating a figure and a set of subplots
fig, ax = plt.subplots(nrows=2, ncols=2)
#plot(), scatter (), show()
import numpy as np
x = np.linspace(0, 10, 100)
y = np.sin(x)
plt.plot(x, y)
# or plt.scatter(x, y) for scatter plot
plt.show()
#output:
#labels, legends, titles, ticks, styles_
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2*np.pi, 100) # Define x from 0 to 2*pi
y = np.sin(x)
plt.plot(x, y, label='sin(x)')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Sine Function')
plt.legend()
plt.grid(True)
plt.show()
#output:
#dynamical updating curves
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
# Generate some data
x = np.linspace(0, 10, 100)
y = np.sin(x)
# Create a figure and axis
fig, ax = plt.subplots()
line, = ax.plot(x, y)
# Function to update the plot
def update_plot(frame):
# Update the data
line.set_ydata(np.sin(x + frame * 0.1))
return line,
# Animate the plot
ani = FuncAnimation(fig, update_plot, frames=range(100), blit=True)
plt.show()
#output:
#saving graphs
plt.savefig('sine_plot.png')
