PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [1]: #Q1) Write a Python program to plot 2D graph of the functions f(x) = x^2 a

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-1, 1, 100)
y1 = x**2
y2 = x**3

plt.plot(x, y1, label='f(x) = x^2')

plt.plot(x, y2, label='g(x) = x^3')
plt.xlabel('x')
plt.ylabel('y')
plt.title('2D Graph of f(x)=x^2 and g(x)=x^3')
plt.legend()
plt.grid(True)
plt.show()

1 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [2]: #Q2) Write a Python program to plot 3D graph of the function f(x) = e−x2 i
# points line with upward pointing triangle.

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')

x = np.linspace(-5, 5, 100)
y = np.exp(-x) ** 2
ax.plot(x, y, zs=0, zdir='z', color='g', linestyle='--', marker='^')

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('f(x)')

plt.show()

2 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [3]: #Q3 using python represent the following information using a bar graph (in
# Item Clothing food Rent Petrol Misc.
# Expenditure in Rs 600 4000 2000 1500 700

import matplotlib.pyplot as plt

items = ['Clothing', 'Food', 'Rent', 'Petrol', 'Misc.']

expenditure = [600, 4000, 2000, 1500, 700]

plt.bar(items, expenditure, color='green')

plt.xlabel('Item')
plt.ylabel('Expenditure in Rs')
plt.title('Expenditure on Different Items')
plt.show()

3 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [4]: #Q4)write a python, program to reflect the line segment joining the point A

import numpy as np

# Define the points A and B

A = np.array([5, 3])
B = np.array([1, 4])

# Define the line y=x+1

def reflect_point(point):
x, y = point
new_x = (2 * 1 * y - x + 1) / 2
new_y = (2 * 1 * x - y - 1) / 2
return np.array([new_x, new_y])

# Reflect points A and B through the line y=x+1

reflected_A = reflect_point(A)
reflected_B = reflect_point(B)

print("Reflected Point A:", reflected_A)

print("Reflected Point B:", reflected_B)

Reflected Point A: [1. 3.]

Reflected Point B: [ 4. -1.5]

4 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [5]: #Q5)Write a python program to draw a polygon with vertices(0,0),(2,0),(2,3)

import matplotlib.pyplot as plt

import numpy as np

# Define the vertices of the polygon

vertices = np.array([[0, 0], [2, 0], [2, 3], [1, 6]])

# Plot the original polygon

plt.figure()
plt.gca().add_patch(plt.Polygon(vertices, closed=True, fill=None, edgecolor
plt.axis('scaled')
plt.title('Original Polygon')

# Rotate the polygon by 180 degrees

rotation_matrix = np.array([[-1, 0], [0, -1]])
rotated_vertices = np.dot(vertices, rotation_matrix)

# Plot the rotated polygon

plt.figure()
plt.gca().add_patch(plt.Polygon(rotated_vertices, closed=True, fill=None
plt.axis('scaled')
plt.title('Rotated Polygon by 180 Degrees')

plt.show()

5 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

6 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [6]: #Q6)write a python program to find the area and perimeter of Triangle ABC w

import math

# Coordinates of points A, B, and C

A = (0, 0)
B = (5, 0)
C = (3, 3)

# Distance between two points

def distance(p1, p2):
return math.sqrt((p2[0] - p1[0])**2 + (p2[1] - p1[1])**2)

# Calculate the sides of the triangle

side_a = distance(B, C)
side_b = distance(A, C)
side_c = distance(A, B)

# Calculate the perimeter of the triangle

perimeter = side_a + side_b + side_c

# Calculate the semi-perimeter

s = perimeter / 2

# Calculate the area of the triangle using Heron's formula

area = math.sqrt(s * (s - side_a) * (s - side_b) * (s - side_c))

print("Perimeter of the triangle ABC:", perimeter)

print("Area of the triangle ABC:", area)

Perimeter of the triangle ABC: 12.848191962583273

Area of the triangle ABC: 7.499999999999997

In [7]: #Q7) write a python program to solve the following LPP.

# Max Z = 150x+75y
# subject to 4x+6y<=24
# 5x+4y<=15
# x>=0,y>=0

from scipy.optimize import linprog

c = [-150, -75] # Coefficients of the objective function to be minimized

A = [[4, 6], [5, 4]] # Coefficients of the left-hand side of inequalities

b = [24, 15] # Right-hand side of inequalities

x_bounds = (0, None) # Bounds for x variable

y_bounds = (0, None) # Bounds for y variable

res = linprog(c, A_ub=A, b_ub=b, bounds=[x_bounds, y_bounds], method=

print('Optimal values:', res.x)

print('Optimal solution:', res.fun)

Optimal values: [3. 0.]

Optimal solution: -450.0

7 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [7]: #Q8)write a python program to display the following LPP by using pulp modul
# Min Z = x+y
# subject to
# x>= =6
# y>= =6
# x+y<=11
# x>=0, y>=0

import pulp

# Create a problem instance

prob = pulp.LpProblem("LPP_Problem", pulp.LpMinimize)

# Define the decision variables

x = pulp.LpVariable("x", lowBound=0)
y = pulp.LpVariable("y", lowBound=0)

# Define the objective function

prob += x + y, "Minimize Z"

# Add the constraints

prob += x >= 6, "Constraint 1"
prob += y >= 6, "Constraint 2"
prob += x + y <= 11, "Constraint 3"

# Solve the problem

prob.solve()

# Display the solution

print("Status:", pulp.LpStatus[prob.status])
print("Optimal solution: Z =", pulp.value(prob.objective))
print("x =", pulp.value(x))
print("y =", pulp.value(y))

Status: Infeasible
Optimal solution: Z = 12.0
x = 6.0
y = 6.0

8 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [6]: #Q9) Apply Python program in each of the following transformations on the
#(I) Refection through X−axis.
#(II) Scaling in X−coordinate by factor 2.
#(III) Scaling in Y−coordinate by factor 1.5.
#(IV) Reflection through the line y = x.

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

def reflect_x_axis(point):
return Point(point.x, -point.y)

def scale_x_coordinate(point, factor):

return Point(point.x * factor, point.y)

def scale_y_coordinate(point, factor):

return Point(point.x, point.y * factor)

def reflect_through_line(point):
return Point(point.y, point.x)

# Initial point P[3, -1]

P = Point(3, -1)

# Transformation (I): Reflection through X-axis

P_reflected_x_axis = reflect_x_axis(P)
print("Reflection through X-axis:", P_reflected_x_axis.x, P_reflected_x_axi

# Transformation (II): Scaling in X-coordinate by factor 2

P_scaled_x = scale_x_coordinate(P, 2)
print("Scaling in X-coordinate by factor 2:", P_scaled_x.x, P_scaled_x

# Transformation (III): Scaling in Y-coordinate by factor 1.5

P_scaled_y = scale_y_coordinate(P, 1.5)
print("Scaling in Y-coordinate by factor 1.5:", P_scaled_y.x, P_scaled_y

# Transformation (IV): Reflection through the line y = x

P_reflected_line = reflect_through_line(P)
print("Reflection through the line y = x:", P_reflected_line.x, P_reflected

Reflection through X-axis: 3 1

Scaling in X-coordinate by factor 2: 6 -1
Scaling in Y-coordinate by factor 1.5: 3 -1.5
Reflection through the line y = x: -1 3

9 of 10 26/03/24, 11:33
PRAJAPATI SANJAY PRACTICAL NO_1 - Jupyter Notebook http://localhost:8888/notebooks/PRAJAPATI%20SAN...

In [7]: #Q10) Find the combined transformation of the line segment between the poi
# by using Python program for the following sequence of transformations:
# (I) Rotation about origin through an angle π.
# (II) Scaling in X− coordinate by 2 units.
# (III) Reflection through the line y = −x.
# (IV) Shearing in X direction by 4 units.

import numpy as np

def rotate_about_origin(point, angle):

rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)]])
return np.dot(rotation_matrix, point)

def scale_x_coordinate(point, scale_factor):

return np.array([point[0] * scale_factor, point[1]])

def reflect_through_line(point):
return np.array([-point[1], -point[0]])

def shear_x_direction(point, shear_factor):

return np.array([point[0] + shear_factor * point[1], point[1]])

# Initial points A and B

point_A = np.array([5, -2])
point_B = np.array([4, 3])

# Applying transformations sequentially

rotated_point_A = rotate_about_origin(point_A, np.pi)
rotated_point_B = rotate_about_origin(point_B, np.pi)

scaled_point_A = scale_x_coordinate(rotated_point_A, 2)
scaled_point_B = scale_x_coordinate(rotated_point_B, 2)

reflected_point_A = reflect_through_line(scaled_point_A)
reflected_point_B = reflect_through_line(scaled_point_B)

sheared_point_A = shear_x_direction(reflected_point_A, 4)
sheared_point_B = shear_x_direction(reflected_point_B, 4)

print("Transformed Point A:", sheared_point_A)

print("Transformed Point B:", sheared_point_B)

Transformed Point A: [38. 10.]

Transformed Point B: [35. 8.]

In [ ]:

10 of 10 26/03/24, 11:33