Python Slip Solution

4/14/24, 10:41 PM slip1
In [1]: # Write a Python program to plot 2D graph of the functions f(x) = x2 and g
(x) = x3 in [−1,1]
import matplotlib.pyplot as plt
import numpy as np
def f(x):
return x**2
def g(x):
return x**3
x=np.linspace(-1,1,100)
y_f=f(x)
y_g=g(x)
fig,ax=plt.subplots()
ax.plot(x,y_f,label='f(x)=x^2')
ax.plot(x,y_g,label='g(x)=x^3')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.legend()
ax.set_title('2D graph of f(x)=x^2 and g(x)=x^3')
plt.show()
https://htmtopdf.herokuapp.com/ipynbviewer/temp/82edebd97348fac70cd1030cd2a9b7c7/slip1.html?t=1713114641201 1/6
4/14/24, 10:41 PM slip1
In [8]: # Using python, represent the following information using a bar graph (in g
reen color )
# Item clothing Food rent Petrol Misc.

# expenditure 600 4000 2000 1500 700
# (in Rs)

left = [1,2,3,4,5]
height = [600,4000,2000,1500,700]
tick_label=['clothing','Food','rent','Petrol','Misc']
plt.bar (left,height,tick_label = tick_label,width = 0.8 ,color = ['gree
n','red'])
plt.xlabel('Item')
plt.ylabel('Expenditure')
plt. show()
4/14/24, 10:41 PM slip1
In [4]: # Write a Python program to draw a polygon with vertices (0,0),(2,0),(2,3)

and (1,6) and rotate
# it by 180◦

import numpy as np
vertices = np.array([[0, 0], [2, 0], [2, 3], [1, 6],[0,0]])
plt.figure()
plt.plot(vertices[:, 0], vertices[:, 1], 'red')
plt.title('Original Polygon')
plt.xlabel('X')
plt.ylabel('Y')
theta = np.pi # 180 degrees

rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
vertices_rotated = np.dot(vertices, rotation_matrix)
plt.figure()
plt.plot(vertices_rotated[:, 0], vertices_rotated[:, 1], 'black')
plt.title('Rotated Polygon (180 degrees)')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
4/14/24, 10:41 PM slip1
4/14/24, 10:41 PM slip1
In [13]: # Write a Python program to find the area and perimeter of the ∆ABC, where
A[0,0],B[5,0],C[3,3].
import numpy as np
A = np.array([0, 0])
B = np.array([5, 0])
C = np.array([3, 3])
# Calculate the side lengths of the triangle
AB = np.linalg.norm(B - A)
BC = np.linalg.norm(C - B)
CA = np.linalg.norm(A - C)
# Calculate the semiperimeter
s = (AB + BC + CA) / 2
# Calculate the area using Heron's formula
area = np.sqrt(s * (s - AB) * (s - BC) * (s - CA))
# Calculate the perimeter
perimeter = AB + BC + CA
# Print the results
print("Triangle ABC:")
print("Side AB:", AB)
print("Side BC:", BC)
print("Side CA:", CA)
print("Area:", area)
print("Perimeter:", perimeter)
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275
4/14/24, 10:41 PM slip1
In [1]: # Write a Python program to solve the following LPP:

# Max Z = 150x + 75y
# subject to 4x + 6y ≤24
# 5x + 3y ≤15
# x ≥0,y ≥0
from pulp import *

# Create the LP problem as a maximization problem
problem = LpProblem("LPP", LpMaximize)
# Define the decision variables
x = LpVariable('x', lowBound=0, cat='Continuous')
y = LpVariable('y', lowBound=0, cat='Continuous')
# Define the objective function
Z = 150 * x + 75 * y
problem += Z
problem += 4 * x + 6 * y <= 24
problem += 5 * x + 3 * y <= 15
# Solve the LP problem
problem.solve()
# Print the status of the solution
print("Status:", LpStatus[problem.status])
# Print the optimal values of x and y
print("Optimal x =", value(x))
print("Optimal y =", value(y))
# Print the optimal value of the objective function
print("Optimal Z =", value(problem.objective))
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
In [3]: # Apply Python program in each of the following transformations on the poin
t P[3,−1]
# (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.
import numpy as np
P = np.array([3,-1])
reflection_x_axis = np.array([1, -1]) * P
scaling_x = np.array([2, 1]) * P
scaling_y = np.array([1, 1.5]) * P
reflection_line = np.array([P[1],P[0]])
print("Original point P:", P)

print("Reflection through y-axis:", reflection_x_axis)
print("Scaling in X-coordinates by factor 2:", scaling_x)
print("Scaling in Y-coordinates by factor 1.5:", scaling_y)
print("Reflection through the line y = x:", reflection_line)
Original point P: [ 3 -1]

Reflection through y-axis: [3 1]
Scaling in X-coordinates by factor 3: [ 6 -1]
Scaling in Y-coordinates by factor 2.5: [ 3. -1.5]
Reflection through the line y = -x: [-1 3]
4/14/24, 10:41 PM slip2
In [1]: # Write a Python program to plot 2D graph of the functions f(x) = log10(x)
and in [0,10]
import numpy as np
x = np.linspace(1,10)
# Compute y values using the function f(x) = log10(x)
y = np.log10(x)
# Plot the graph
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('f(x) = log10(x)')
plt.title('2D Graph of f(x) = log10(x)')
plt.grid(True)
plt.show()
4/14/24, 10:41 PM slip2
In [3]: # Using python, represent the following information using a bar gr

aph (in
# green color)
# Subject Maths Science English Marathi Hindi
# Percentage 68 90 70 85 91

left = [1,2,3,4,5]
height = [68,90,70,85,91]
tick_label=['Maths','Science','English','Marathi','Hindi']
n','green'])
plt.xlabel('Item')
plt. show()
4/14/24, 10:41 PM slip2
In [4]: # Using sympy declare the points A(0,2),B(5,2),C(3,0) check whether these p
oints are collinear.
# Declare the line passing through the points A and B, find the distance of
this line from point C.
from sympy import Point, Line

# Declare the points A, B, and C
A = Point(0, 2)
B = Point(5, 2)
C = Point(3, 0)
# Check if points A, B, and C are collinear
collinear = Point.is_collinear(A, B, C)
if collinear:
print("Points A, B, and C are collinear.")
else:
print("Points A, B, and C are not collinear.")
# Declare the line passing through points A and B
AB_line = Line(A, B)
# Find the distance of the line AB from point C
distance = AB_line.distance(C)
print("Distance of the line passing through A and B from point C: ", distan
ce)
Points A, B, and C are not collinear.

Distance of the line passing through A and B from point C: 2
In [1]: # Write a Python program to find the area and perimeter of the ABC, where
# A[0, 0] B[6, 0], C[4,4].
import numpy as np
# Define the vertices of the triangle
s = (AB + BC + CA) / 2
# Print the results
Triangle ABC:
Side AB: 6.0
Side BC: 4.47213595499958
Side CA: 5.656854249492381
Area: 11.999999999999998
Perimeter: 16.12899020449196
4/14/24, 10:41 PM slip2

# Max Z = 5x + 3y
# subject to x + y ≤7
# 2x + 5y ≤1
# x ≥0,y ≥0
from pulp import *

Z = 5 * x + 3 * y
problem += Z
problem += x + y <= 7
problem += 2*x +5* y <= 1
problem.solve()
Status: Optimal
Optimal x = 0.5
Optimal y = 0.0
Optimal Z = 2.5
4/14/24, 10:41 PM slip2
t P[4,−2]
# (I) Refection through Y−axis.
# (III) Scaling in Y−coordinate by factor 2.5
# (IV) Reflection through the line y = −x.
import numpy as np
P = np.array([4, -2])
# Reflection through y-axis
reflection_y_axis = np.array([-1, 1]) * P
# Scaling in X-coordinates by factor 3
# Scaling in Y-coordinates by factor 2.5
# Reflection through the line y = -x
reflection_line = np.array([-P[1],-P[0]])
print("Reflection through y-axis:", reflection_y_axis)
print("Reflection through the line y = -x:", reflection_line)

Reflection through y-axis: [-4 -2]
Scaling in X-coordinates by factor 3: [12 -2]
Scaling in Y-coordinates by factor 2.5: [ 4. -5.]
Reflection through the line y = -x: [ 2 -4]
4/14/24, 10:42 PM slip3
In [1]: # Using Python plot the graph of function f(x) = cos(x) on the interval [0,
2π].
import numpy as np
x = np.linspace(0,2*np.pi)
y = np.cos(x)
plt.plot(x, y)
plt.xlabel('x')
plt.show()
4/14/24, 10:42 PM slip3
In [2]: # Following is the information of students participating in various games i

n a school. Represent it
# by a Bar graph with bar width of 0.7 inches.
# Game Cricket Football Hockey Chess Tennis
# Number of students 65 30 54 10 20

left = [1,2,3,4,5]
height = [65,30,54,10,20]
tick_label=['Cricket','Football','Hockey','Chess','Tennis']
plt.bar (left,height,tick_label = tick_label,width = 0.7 ,color = ['orang
e','green'])
plt.xlabel('Games')
plt.ylabel('No.Of Student')
plt. show()
4/14/24, 10:42 PM slip3
In [6]: # f the line with points A[2,1],B[4,−1] is transformed by the transformatio

n matrix [T] =[1 2
# 2 1]
# then using python, find the equation of transformed line
import numpy as np
B = np.array([4, -1])
T = np.array([[1, 2], [2, 1]])
A_transformed = np.dot(T, A)
B_transformed = np.dot(T, B)
# Extract coordinates of transformed points
x1_transformed, y1_transformed = A_transformed
x2_transformed, y2_transformed = B_transformed
m_transformed = (y2_transformed - y1_transformed) / (x2_transformed - x1_tr

ansformed)
b_transformed = y1_transformed - m_transformed * x1_transformed

# Format the equation of the transformed line
equation_transformed = f'y = {m_transformed} * x + {b_transformed}'
print("Equation of transformed line: ", equation_transformed)
Equation of transformed line: y = -1.0 * x + 9.0
In [7]: # Generate line segment having endpoints (0,0) and (10,10) find midpoint of
line segment
x1, y1 = 0, 0
x2, y2 = 10, 10
# Calculate midpoint
midpoint_x = (x1 + x2) / 2
midpoint_y = (y1 + y2) / 2
# Print midpoint
print("Midpoint: ({}, {})".format(midpoint_x, midpoint_y))
Midpoint: (5.0, 5.0)
4/14/24, 10:42 PM slip3

# Min Z = 3.5x + 2y
# subject to x + y ≥5
# x ≥4
# y ≤2
# x ≥0,y ≥0
from pulp import *
problem= LpProblem("Minimize Z", LpMinimize)

x= LpVariable("x", lowBound=0, cat='Continuous')
y= LpVariable("y", lowBound=0, cat='Continuous')
Z = 3.5 * x + 2 * y
problem+= Z
problem+= x + y >= 5
problem+= x >= 4
problem+= y <= 2
problem.solve()
print("Optimal solution:")
print("x =", value(x))
print("y =", value(y))
print("Optimal value of Z =",value(problem.objective))
Optimal solution:
x = 4.0
y = 1.0
Optimal value of Z = 16.0
4/14/24, 10:42 PM slip3
t P[4,−2]
import numpy as np
P = np.array([4, -2])
# Scaling in Y-coordinates by factor 2.5

Scaling in Y-coordinates by factor 2.5: [ 4. -5.]
4/14/24, 10:43 PM slip4
In [1]: # Write a Python program to plot 2D graph of the functions f(x) = log10(x)
in the [0,10]
import numpy as np
x = np.linspace(1,10)
# Compute y values using the function f(x) = log10(x)
y = np.log10(x)
# Plot the graph
plt.plot(x, y)
plt.xlabel('x')
plt.grid(True)
plt.show()
4/14/24, 10:43 PM slip4
In [2]: # Using Python plot the graph of function f(x) = sin−1(x) on the interval
[−1,1]
import numpy as np
x = np.linspace(-1,1)
y = 1/np.sin(x)
# Plot the graph
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('f(x) = sin-1(X)')
plt.grid(True)
plt.show()
4/14/24, 10:43 PM slip4
In [3]: # if the line with points A[3,1],B[5,−1] is transformed by the transformati

on matrix [T] =[3 −2
# 2 1]
# then using python, find the equation of transformed line.
import numpy as np
B = np.array([5, -1])
T = np.array([[3, -2], [2, 1]])
A_transformed = np.dot(T, A)
B_transformed = np.dot(T, B)
# Extract coordinates of transformed points
x1_transformed, y1_transformed = A_transformed
x2_transformed, y2_transformed = B_transformed
m_transformed = (y2_transformed - y1_transformed) / (x2_transformed - x1_tr

ansformed)
b_transformed = y1_transformed - m_transformed * x1_transformed

# Format the equation of the transformed line
equation_transformed = f'y = {m_transformed} * x + {b_transformed}'
print("Equation of transformed line: ", equation_transformed)
Equation of transformed line: y = 0.2 * x + 5.6
4/14/24, 10:43 PM slip4
In [2]: # Using python, generate line passing through points (2,3) and (4,3) and fi
nd equation of the line
import numpy as np
# Define the points
x = np.array([2, 4])
y = np.array([3, 3])
# Calculate the slope (m) and y-intercept (b) of the line
m = (y[1] - y[0]) / (x[1] - x[0])
b = y[0] - m * x[0]
# Print the equation of the line
print(f"The equation of the line is: y = {m : .2f}x + {b:.2f}")
# Plot the points and the line
plt.scatter(x, y, c='blue', label='Points')
plt.plot(x, m * x + b, c='red', label='Line')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Line Passing through Points')
plt.legend()
plt.show()
The equation of the line is: y = 0.00x + 3.00
4/14/24, 10:43 PM slip4

# Max Z = 150x + 75y
# 5x + 3y ≤15
# x ≥0,y ≥0.
from pulp import *

Z=150 * x + 75 * y
problem += Z
# Define the constraints
problem += 4 * x + 6 * y <= 24
problem += 5 * x + 3 * y <= 15
problem.solve()
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
4/14/24, 10:43 PM slip4
In [4]: # Find the combined transformation of the line segment between the points A
[4,−1] & B[3,0]
# by using Python program for the following sequence of transformations:-
# (I) Shearing in X direction by 9 units.
# (II) Rotation about origin through an angle π.
# (III) Scaling in X− coordinate by 2 units.
# (IV) Reflection through the line y = x.
import numpy as np
# Input points A and B
A = np.array([4, -1])
# Transformation 1: Shearing in X-Direction by 9 units
shear_matrix = np.array([[1, 9],
[0, 1]])
A_sheared = np.dot(shear_matrix, A)
B_sheared = np.dot(shear_matrix, B)
print("Transformed Point A after Shearing:", A_sheared)
print("Transformed Point B after Shearing:", B_sheared)
# Transformation 2: Rotation about origin through an angle of pi (180 degre

es)
rotation_matrix = np.array([[np.cos(np.pi), -np.sin(np.pi)],
[np.sin(np.pi), np.cos(np.pi)]])
A_rotated = np.dot(rotation_matrix, A_sheared)
B_rotated = np.dot(rotation_matrix, B_sheared)
print("Transformed Point A after Rotation:", A_rotated)
print("Transformed Point B after Rotation:", B_rotated)
# Transformation 3: Scaling in X-Coordinate by 2 units
scaling_matrix = np.array([[2, 0],
[0, 1]])
A_scaled = np.dot(scaling_matrix, A_rotated)
B_scaled = np.dot(scaling_matrix, B_rotated)
print("Transformed Point A after Scaling:", A_scaled)
print("Transformed Point B after Scaling:", B_scaled)
# Transformation 4: Reflection through the line y = x
reflection_matrix = np.array([[0, 1],
[1, 0]])
A_reflected = np.dot(reflection_matrix, A_scaled)
B_reflected = np.dot(reflection_matrix, B_scaled)
print("Transformed Point A after Reflection:", A_reflected)
print("Transformed Point B after Reflection:", B_reflected)
Transformed Point A after Shearing: [-5 -1]

Transformed Point B after Shearing: [3 0]
Transformed Point A after Rotation: [5. 1.]
Transformed Point B after Rotation: [-3.0000000e+00 3.6739404e-16]
Transformed Point A after Scaling: [10. 1.]
Transformed Point B after Scaling: [-6.0000000e+00 3.6739404e-16]
Transformed Point A after Reflection: [ 1. 10.]
Transformed Point B after Reflection: [ 3.6739404e-16 -6.0000000e+00]
4/14/24, 10:44 PM slip5
In [1]: # Using Python plot the surface plot of function z = cos (x2 + y2 −0.5)in t
he interval from −1 < x,y < 1
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
def func(x, y):

return np.cos(x**2 + y**2 - 0.5)
# Generate x, y values in the interval from -1 to 1
x = np.linspace(-1, 1, 100)
y = np.linspace(-1, 1, 100)
X, Y = np.meshgrid(x, y) # Create a grid of x, y values
Z = func(X, Y) # Compute z values using the function
# Create a 3D plot
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X, Y, Z, cmap='viridis') # Plot the surface
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Surface Plot of z = cos(x**2 + y**2 - 0.5)')
plt.show() # Show the plot
4/14/24, 10:44 PM slip5
In [2]: # Generate 3D surface Plot for the function f(x) = sin (x2 + y2)in the inte
rval [0,10]
import numpy as np
# Define the function
def func(x, y):
return np.sin(x**2 + y**2)
# Generate x, y values in the interval from 0 to 10
x = np.linspace(0, 10, 100)
y = np.linspace(0, 10, 100)
# Create a 3D plot
fig = plt.figure()
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Surface Plot of f(x) = sin(x**2 + y**2)')
plt.show() # Show the plo
4/14/24, 10:44 PM slip5
In [9]: # Using python, generate triangle with vertices (0,0),(4,0),(4,3) check whe
ther the triangle is Right angle triangle

vertex1 = (0, 0)
vertex2 = (4, 0)
vertex3 = (4, 3)
# Extract x and y coordinates of the vertices
x = [vertex1[0], vertex2[0], vertex3[0], vertex1[0]]
y = [vertex1[1], vertex2[1], vertex3[1], vertex1[1]]
# Plot the triangle
plt.plot(x, y, 'black', label='Triangle')
plt.plot(vertex1[0], vertex1[1], 'ro', label='Vertex 1')
plt.plot(vertex2[0], vertex2[1], 'go', label='Vertex 2')
plt.plot(vertex3[0], vertex3[1], 'mo', label='Vertex 3')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Triangle with Vertices')
plt.legend()
plt.grid(True)
plt.show()
4/14/24, 10:44 PM slip5
A[0,0],B[6,0],C[4,4]
import numpy as np
s = (AB + BC + CA) / 2
# Print the results
Triangle ABC:
Side AB: 6.0
Side BC: 4.47213595499958
Side CA: 5.656854249492381
Area: 11.999999999999998
Perimeter: 16.12899020449196
4/14/24, 10:44 PM slip5

# Max Z = 5x + 3y
# 2x + 5y ≤1
# x ≥0,y ≥0
from pulp import *

Z=5 * x + 3 * y
problem += Z
problem += 2 * x + 5 * y <= 1
problem.solve()
Status: Optimal
Optimal x = 0.5
Optimal y = 0.0
Optimal Z = 2.5
4/14/24, 10:44 PM slip5
t P[3,8]
# (III) Rotation about origin through an angle 30◦.
import numpy as np
P=np.array([3,8])
# Scaling in X−coordinate by factor 6.
# Rotation about origin through an angle 30◦.
rotation_matrix = np.array([[np.cos(np.pi/6), -np.sin(np.pi/6)],
[np.sin(np.pi/6), np.cos(np.pi/6)]])
P_rotation = np.dot(rotation_matrix, P)

print("Rotation about origin through an angle of 30 degree:",P_rotation)
Original point P: [3 8]
Reflection through y-axis: [ 3 -8]
Scaling in X-coordinates by factor 6: [18 8]
Rotation about origin through an angle of 30 degree: [-1.40192379 8.428203
23]
Reflection through the line y = -x: [-8 -3]
4/14/24, 10:45 PM slip6
In [1]: # Using python, generate 3D surface Plot for the function f(x) = sin (x2 +
y2)in the interval [0,10]
import numpy as np
def func(x, y):
# Create a 3D plot
fig = plt.figure()
ax.plot_surface(X, Y, Z) # Plot the surface
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
4/14/24, 10:45 PM slip6
In [4]: # Draw the horizontal bar graph for the following data in Maroon colour.
# City Pune Mumbai Nasik Nagpur Thane
# Air Quality Index 168 190 170 178 195

# Data
left = [1, 2, 3, 4, 5]
height = [168, 190, 170, 178, 195]
tick_label = ['Pune', 'Mumbai', 'Nasik', 'Nagpur', 'Thane']
# Create a horizontal bar graph
plt.barh(left, height, tick_label=tick_label, color='red')
# Set labels and title
plt.xlabel('Air Quality Index')
plt.ylabel('City')
plt.title('Air Quality Index by City (Horizontal Bar Graph)')
# Show the plot
plt.show()
4/14/24, 10:45 PM slip6
In [5]: # using python, rotate the line segment by 180◦ having end points (1,0) and
(2,−1).
import numpy as np
# Define the original line segment
x1, y1 = 1, 0
x2, y2 = 2, -1
# Plot the original line segment
plt.plot([x1, x2], [y1, y2], 'bo-', label='Original Line')
# Compute the rotated coordinates
x1_rot, y1_rot = -x1, -y1
x2_rot, y2_rot = -x2, -y2
# Plot the rotated line segment
plt.plot([x1_rot, x2_rot], [y1_rot, y2_rot], 'ro-', label='Rotated Line')
# Set axis limits
plt.xlim(-3, 3)
plt.ylim(-3, 3)
# Add labels and title
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Rotation of Line Segment by 180 degrees')
# Add legend
plt.legend()
# Show the plot
plt.show()
4/14/24, 10:45 PM slip6

and (1,6) and rotate it by 180◦
import numpy as np
# Define the vertices of the polygon

vertices = np.array([[0, 0], [2, 0], [2, 3], [1, 6],[0,0]])
# Plot the original polygon

plt.figure()
plt.plot(vertices[:, 0], vertices[:, 1], 'red')
plt.xlabel('X')
plt.ylabel('Y')
# Rotate the polygon by 180 degrees
rotation_matrix = np.array([[np.cos(np.pi), -np.sin(np.pi)], [np.sin(np.p

i), np.cos(np.pi)]])
rotated_vertices = np.dot(vertices, rotation_matrix)
# Plot the rotated polygon

plt.figure()
plt.plot(rotated_vertices[:, 0], rotated_vertices[:, 1], 'black')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
4/14/24, 10:45 PM slip6
4/14/24, 10:45 PM slip6

# Max Z = x + y
# subject to 2x −2y ≥1
# x + y ≥2
# x ≥0,y ≥0
from pulp import *

Z= x + y
problem += Z
problem += 2*x - 2*y >= 1
problem += x + y >= 2
problem.solve()
Status: Unbounded
Optimal x = 0.0
Optimal y = 0.0
Optimal Z = 0.0
4/14/24, 10:45 PM slip6
t P[4,−2]
# (III) Shearing in Y direction by 3 units
import numpy as np
P = [4, -2]
# Shearing in Y-direction by 3 units
shearing_y = [P[0], P[1] + (3 * P[0])]


print("Shearing in Y-direction by 3 units: ",shearing_y)
Original point P: [4, -2]

Shearing in Y-direction by 3 units: [4, 10]
4/14/24, 10:47 PM slip7
In [4]: # Plot the graph of f(x) = x4 in [0,5] with red dashed line with circle mar
kers.
import numpy as np
# Define the function f(x) = x**4
def f(x):
return x**4
# Generate x values in the interval [0, 5]
x = np.linspace(0, 5,100)
# Generate y values using the function f(x)
y = f(x)
# Plot the graph with red dashed line and circle markers
plt.plot(x, y, 'r--o', markersize=6)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x) = x**4')
plt.show()
4/14/24, 10:47 PM slip7
In [6]: # Using python, generate 3D surface Plot for the function f(x) = sin (x2 +
y2)in the interval [0,10].
# also in slip 6 q1
import numpy as np
def func(x, y):
# Create a 3D plot
fig = plt.figure()
ax.plot_surface(X, Y, Z) # Plot the surface
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
4/14/24, 10:47 PM slip7
In [9]: # Write a Python program to reflect the line segment joining the points A
[5,3] & B[1,4] through the line y = x + 1

import numpy as np
# Define the equation of the reflection line
reflection_line = lambda x: x + 1
# Plot the original line segment AB
plt.plot([A[0], B[0]], [A[1], B[1]], '-o', label='Original Line Segment A
B')
# Plot the reflection line
x_vals = np.linspace(-5, 5, 100) # Generate x values for the plot
plt.plot(x_vals, reflection_line(x_vals), '-r', label='Reflection Line y =
x + 1')
# Calculate the reflected points
reflected_A = np.array([reflection_line(A[0]), A[0]])
reflected_B = np.array([reflection_line(B[0]), B[0]])
# Plot the reflected line segment A'B'
plt.plot([reflected_A[0], reflected_B[0]], [reflected_A[1], reflected_B
[1]], '-o', label='Reflected Line Segment A\'B\'')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Line Segment Reflection')
plt.legend()
plt.show()
4/14/24, 10:47 PM slip7
In [10]: # Using sympy declare the points P(5,2),Q(5,−2),R(5,0), check whether these
points are collinear.
# Declare the ray passing through the points P and Q, find the length of th
is ray between P and Q.Also find slope of this ray.
P = Point(5, 2)
Q = Point(5, -2)
R = Point(5, 0)
# Check if points P, Q, and R are collinear
line_PQ = Line(P, Q)
line_PR = Line(P, R)
collinear = line_PQ.is_parallel(line_PR)
# Print the result
if collinear:
print("Points P, Q, and R are collinear")
else:
print("Points P, Q, and R are not collinear")
# Calculate the length of the ray PQ
length_PQ = P.distance(Q)
# Calculate the slope of the ray PQ
slope_PQ = (Q.y - P.y) / (Q.x - P.x)
# Print the length and slope of the ray PQ
print("Length of the ray PQ:", length_PQ)
print("Slope of the ray PQ:", slope_PQ)
Points P, Q, and R are collinear

Length of the ray PQ: 4
Slope of the ray PQ: zoo
4/14/24, 10:47 PM slip7

# Min Z = 3.5x + 2y
# x ≥4
# y ≤2
# x ≥0,y ≥0
from pulp import *

Z = 3.5 * x + 2 * y
problem+= Z
problem+= x >= 4
problem+= y <= 2
problem.solve()
Status: Optimal
x = 4.0
y = 1.0
4/14/24, 10:47 PM slip7
t P[4,−2]
# (III) Rotation about origin through an angle π/2 .
# (IV) Shearing in X direction by 7 / 2 units
import numpy as np
P=np.array([4,-2])
# (III) Rotation about origin through an angle π/2 .
# (IV) Shearing in X direction by 7 / 2 units
shearing_x = [P[0]+((7/2)*P[1]),P[1]]

print("Shearing in x-direction by 7/2 units: ",shearing_x)

Rotation about origin through an angle of 30 degree: [2. 4.]
Shearing in x-direction by 7/2 units: [-3.0, -2]
4/14/24, 10:47 PM slip8
In [1]: # Using Python plot the graph of function f(x) = cos(x) in the interval [0,
2π].
import numpy as np
# Generate x values
x = np.linspace(0, 2 * np.pi, 500)
y = np.cos(x)
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('f(x) = cos(x)')
plt.title('Graph of f(x) = cos(x)')
plt.grid(True)
plt.show()
4/14/24, 10:47 PM slip8
In [4]: # Write a Python program to generate 3D plot of the functions z = sin x+ co

s y in −10 < x,y < 10
import numpy as np
x = np.linspace(-10, 10, 100)

y = np.linspace(-10, 10, 100)
X, Y = np.meshgrid(x, y)
# Compute z values for the function z = sin(x) + cos(y)
Z = np.sin(X) + np.cos(Y)
# Create a 3D plot
fig = plt.figure()
ax.plot_surface(X, Y, Z)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('3D Plot of z = sin(x) + cos(y)')
plt.show()
4/14/24, 10:47 PM slip8
In [9]: # Using python, generate triangle with vertices (0,0),(4,0),(1,4), check wh

ether the triangle isScalene triangle

# Vertices of the triangle
vertex1 = (0, 0)
vertex2 = (4, 0)
vertex3 = (1, 4)
# Plot the triangle
plt.plot(*zip(vertex1, vertex2, vertex3, vertex1), marker='o')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Triangle')
plt.grid(True)
plt.show()
4/14/24, 10:47 PM slip8
A[0,0],B[6,0],C[4,4]
import numpy as np
s = (AB + BC + CA) / 2
# Print the results
Triangle ABC:
Side AB: 6.0
Side BC: 4.47213595499958
Side CA: 5.656854249492381
Area: 11.999999999999998
Perimeter: 16.12899020449196
4/14/24, 10:47 PM slip8

# Max Z = 150x + 75y
# 5x + 3y ≤15
# x ≥0,y ≥0
from pulp import *

Z= 150*x + 75*y
problem += Z
problem += 4*x + 6*y <=24
problem += 5*x + 3*y <=15
problem.solve()
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
4/14/24, 10:47 PM slip8
t P[4,−2]
# (III) Rotation about origin through an angle π.
# (IV) Shearing in both X and Y direction by −2 and 4 units respectively
import numpy as np
P=np.array([4,-2])
# (III) Rotation about origin through an angle π .
rotation_matrix = np.array([[np.cos(np.pi), -np.sin(np.pi)],
[np.sin(np.pi), np.cos(np.pi)]])
# (IV) Shearing in both X and Y direction by −2 and 4 units
P_sheared = np.array([P[0] + (-2 * P[1]), P[1] + (4 * P[0])])

print(" Shearing in both X and Y direction by -2 and 4 units respectivel
y:")
print("Shearing in both X and Y direction by −2 and 4 units:",P_sheared)

Rotation about origin through an angle of 180 degree: [-4. 2.]
Shearing in both X and Y direction by -2 and 4 units respectively:
Shearing in X direction: [8, -2]
Shearing in Y direction: [4, 14]
4/14/24, 10:48 PM slip9
In [1]: # Write a python program to Plot 2D X-axis and Y-axis black color and in th
e same diagram plot green triangle with vertices [5,4],[7,4],[6,6].

triangle_vertices = [[5, 4], [7, 4], [6, 6]]
x = [vertex[0] for vertex in triangle_vertices]

y = [vertex[1] for vertex in triangle_vertices]
# Plot the X-axis and Y-axis in black color
plt.axhline(0, color='black')
plt.axvline(0, color='black')
# Plot the triangle with green color
plt.plot(x + [x[0]], y + [y[0]], 'g')
# Set the plot limits and labels
plt.xlim(4, 8)
plt.ylim(3, 7)
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
# Show the plot
plt.show()
4/14/24, 10:48 PM slip9
In [5]: # Using Python plot the graph of function f(x) = cos(x) on the interval [0,
2π].
import numpy as np
# Generate x values
y = np.cos(x)
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('f(x) = cos(x)')
plt.title('Graph of f(x) = cos(x)')
plt.grid(True)
plt.show()
4/14/24, 10:48 PM slip9
In [6]: # Using sympy, declare the points A(0,7),B(5,2). Declare the line segment p
assing through them.
# Find the length and midpoint of the line segment passing through points A
and B
A = Point(0, 7)
B = Point(5, 2)
# Declare the line passing through points A and B
line_AB = Line(A, B)
# Calculate the length of the line segment AB
length_AB = A.distance(B)
# Calculate the midpoint of the line segment AB
midpoint_AB = ((A[0] + B[0]) / 2, (A[1] + B[1]) / 2)
# Print the results
print("Point A: {}".format(A))
print("Point B: {}".format(B))
print("Line segment AB: {}".format(line_AB))
print("Length of line segment AB: {}".format(length_AB))
print("Midpoint of line segment AB: {}".format(midpoint_AB))
Point A: Point2D(0, 7)
Point B: Point2D(5, 2)
Line segment AB: Line2D(Point2D(0, 7), Point2D(5, 2))
Length of line segment AB: 5*sqrt(2)
Midpoint of line segment AB: (5/2, 9/2)
In [7]: # Write a python program to find the area and perimeter of ∆ABC where A(0,
0),B(5,0),C(3,3)
import numpy as np
s = (AB + BC + CA) / 2
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275
4/14/24, 10:48 PM slip9

# Max Z = 150x + 75y
# 5x + 3y ≤15
# x ≥0,y ≥0
from pulp import *

Z= 150*x + 75*y
problem += Z
problem += 4*x + 6*y <=24
problem += 5*x + 3*y <=15
problem.solve()
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
4/14/24, 10:48 PM slip9
In [10]: # Write a python program to apply the following transformations on the poin
t (−2,4) :
# (I) Shearing in Y direction by 7 units.
# (II) Scaling in X and Y direction by 7/2 and 7 units respectively.
# (III) Shearing in X and Y direction by 4 and 7 units respectively.
# (IV) Rotation about origin by an angle 60◦.
import numpy as np
P=np.array([-2,4])
shearing_y1 = [P[0], P[1] + (7 * P[0])]
# (II) Scaling in X and Y direction by 7/2 and 7
scaling_x = np.array([7/2, 1]) * P
scaling_y = np.array([1, 7]) * P
shearing_x = [P[0] + (4 * P[1]), P[1]]
shearing_y = [P[0], P[1] + (7 * P[0])]

print("Shearing in Y direction:", shearing_y1)
print("Scaling in X-coordinates by factor 7/2:", scaling_x)
print("Scaling in Y-coordinates by factor 7:", scaling_y)
print(" Shearing in both X and Y direction by 4 and 7 units respectively:")
print("Shearing in X direction:", shearing_x)
print("Shearing in Y direction:", shearing_y)
Original point P: [-2 4]

Shearing in Y direction: [-2, -10]
Scaling in X-coordinates by factor 7/2: [-7. 4.]
Scaling in Y-coordinates by factor 7: [-2 28]
Shearing in both X and Y direction by 4 and 7 units respectively:
Shearing in X direction: [14, 4]
19]
4/14/24, 10:49 PM slip10
In [3]: # Represent the following information using a bar graph (in green color )
# Item clothing Food rent Petrol Misc.
# expenditure in Rs 600 4000 2000 1500 700

left = [1,2,3,4,5]
height = [600,4000,2000,1500,700]
tick_label=['clothing','food','rent','petrol','Misc']
plt.bar(left , height ,tick_label=tick_label, width = 0.8 ,color = ['gree
n','red'])
plt.xlabel('Item')
plt. show()
4/14/24, 10:49 PM slip10
In [4]: # Write a python program to plot the 3D line graph whose parametric equatio
n is (cos(2x),sin(2x),x)
# for 10 ≤x ≤20 (in red color ), with title to the graph.
import numpy as np
x = np.linspace(10, 20, 500)

# Calculate parametric equations for x, y, z
y = np.sin(2 * x)
z = x
x = np.cos(2 * x)
# Create a 3D figure
fig = plt.figure()
ax.plot(x, y, z, color='red')
ax.set_title("3D Line Graph: (cos(2x), sin(2x), x)")

ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
plt.show()
4/14/24, 10:49 PM slip10
In [5]: # Write a python program to rotate the ∆ABC by 90◦ where A(1,1),B(2,−2),C
(1,2)
import numpy as np
# Define the original points
B = np.array([2, -2])
# Define the rotation matrix for rotation by 90 degrees counterclockwise

angle = np.radians(90)
rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)]])
# Apply the rotation to the points
A_rotated = np.dot(rotation_matrix, A)
B_rotated = np.dot(rotation_matrix, B)
C_rotated = np.dot(rotation_matrix, C)
# Print the rotated points
print("Rotated Point A: ", A_rotated)
print("Rotated Point B: ", B_rotated)
print("Rotated Point C: ", C_rotated)
Rotated Point A: [-1. 1.]

Rotated Point B: [2. 2.]
Rotated Point C: [-2. 1.]
In [6]: # Find the area and perimeter of the ∆ABC, where A[0,0],B[5,0],C[3,3]
import numpy as np
s = (AB + BC + CA) / 2
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275
4/14/24, 10:49 PM slip10
In [7]: # Solve LPP by using python:

# Max Z = x + y
# subject to x −y ≥1
# x + y ≥2
# x ≥0,y ≥0
from pulp import *

Z= x + y
problem += Z
problem += x - y >=1
problem += x + y >=2
problem.solve()
Status: Unbounded
Optimal x = 0.0
Optimal y = 0.0
Optimal Z = 0.0
4/14/24, 10:49 PM slip10
t (−2,4) :
# (III) Shearing in X direction by 4 units.
# (IV) Rotate about origin through an angle 30◦.
import numpy as np
P=np.array([-2,4])

shearing_x = [P[0] + (4 * P[1]), P[1]]

print("Reflection through x-axis:", reflection_x_axis)

Scaling in X-coordinates by factor 6: [-12 4]
62]
4/14/24, 10:50 PM slip11
In [1]: # Plot the graph of y = e−x2 in [−5,5] with red dashed-points line with Upw
ard Pointing triangle

import numpy as np
# Generate x values in the range [-5,5]
# Compute y values using y = e**-x
y = np.exp(-x)
# Create a figure and axis
fig, ax = plt.subplots()
# Plot the graph with red dashed line and upward pointing triangles as mark
ers
ax.plot(x, y, 'r--', marker='^')
# Set labels for the x-axis and y-axis
ax.set_xlabel('x')
ax.set_ylabel('y')
# Set title for the plot
ax.set_title('Graph of y = e**-x')
# Display the plot
plt.show()
4/14/24, 10:50 PM slip11
In [3]: # Draw a bar graph in GREEN colour to represent the data below:
# Subject Maths Science English Marathi Hindi
# Percentage of passing 68 90 70 85 91

left = [1,2,3,4,5]
height = [68,90,70,85,91]
tick_label=['Maths','Science','English','Marathi','Hindi']
n','green'])
plt.xlabel('Subject')
plt.ylabel('Percentage of passing')
plt. show()
4/14/24, 10:50 PM slip11
In [4]: # Write a python program to rotate the ∆ABC by 90◦ where A(1,2),B(2,−2),C
(−1,2)
import numpy as np
B = np.array([2, -2])
C = np.array([-1, 2])
# Define the rotation matrix for rotation by 90 degrees counter clockwise


Rotated Point C: [-2. -1.]
In [5]: #Write a python program to reflect the ∆ABC through the line y = 3 where A
(1,0),B(2,−1),C(−1,3)
import numpy as np
# Define the reflection line y = 3
reflection_line = 3
# Define the points A, B, and C
B = np.array([2, -2])
C = np.array([-1, 2])
# Compute the reflected points A', B', and C'
Ap = np.array([A[0], 2 * reflection_line - A[1]])
Bp = np.array([B[0], 2 * reflection_line - B[1]])
Cp = np.array([C[0], 2 * reflection_line - C[1]])
# Print the original points and reflected points
print("Original Points:")
print("A: ", A)
print("B: ", B)
print("C: ", C)
print("Reflected Points:")
print("A':", Ap)
print("B':", Bp)
print("C':", Cp)
Original Points:
A: [1 0]
B: [ 2 -2]
C: [-1 2]
Reflected Points:
A': [1 6]
B': [2 8]
C': [-1 4]
4/14/24, 10:50 PM slip11
In [7]: # Solve LPP by using python:

# Min Z = x + y
# subject to x ≥6
# y ≥6
# x + y ≥11
# x ≥0,y ≥0
from pulp import *

Z = x + y
problem+= Z
problem+= x >= 6
problem+= y >= 6
problem+= x + y >=11
problem.solve()
Status: Optimal
x = 6.0
y = 6.0
4/14/24, 10:50 PM slip11
t (−2,4) :
# (IV) Rotation about origin by an angle 45◦
import numpy as np
P=np.array([-2,4])
# (I) Shearing in Y direction by 7 units
shearing_y1 = [P[0], P[1] + (7 * P[0])]
P_scaled = np.array([P[0] * 3/2, P[1] * 4])
P_sheared = np.array([P[0] + (2 * P[1]), P[1] + (4 * P[0])])


print("Shearing in Y direction by 7 unit:", shearing_y1)
print("Scaling in X and Y direction by 3/2 and 4:",P_scaled)
print("Shearing in X and Y direction by 2 and 4 units:",P_sheared)

Shearing in Y direction by 7 unit: [-2, -10]
Scaling in X and Y direction by 3/2 and 4: [-3. 16.]
Shearing in X and Y direction by 2 and 4 units: [ 6 -4]
56]
4/14/24, 10:52 PM slip12
In [3]: # Write a python program to plot the graph of y = x3 + 10x −5, for x ∈[−10,
10] in red colour
import numpy as np
# Generate x values in the range [-10, 10]

x = np.linspace(-10, 10, 500)
y = x**3 + 10*x - 5
plt.plot(x, y, color='red')
# Set the plot title and axis labels
plt.title("Graph of y = x**3 + 10*x - 5")
plt.xlabel("x")
plt.ylabel("y")
# Show the plot
plt.show()
4/14/24, 10:52 PM slip12
In [5]: # Using Python plot the graph of function f(x) = x2 on the interval [−2,2]
import numpy as np
# Generate x values in the range (-2,2) with a step of 0.1

x = np.arange(-2, 2, 0.1)
y = x**2
# Create the plot
plt.plot(x, y, label='f(x) = x^2',color='red')
plt.title('Graph of f(x) = x^2')

plt.xlabel('x')
plt.ylabel('f(x)')
# Add a legend
plt.legend()
plt.show()
4/14/24, 10:52 PM slip12
In [6]: # Write a python program to rotate the segment by 180◦ having end points
(1,0) and (2,−1).
import math
# Define the endpoints of the line segment
x1, y1 = 1, 0
x2, y2 = 2, -1
# Perform the rotation
x1_rotated = -x1
y1_rotated = -y1
x2_rotated = -x2
y2_rotated = -y2
# Print the original and rotated endpoints
print("Original Endpoint 1: ({}, {})".format(x1, y1))
print("Rotated Endpoint 1: ({}, {})".format(x1_rotated, y1_rotated))
Original Endpoint 1: (1, 0)

Original Endpoint 2: (2, -1)
Rotated Endpoint 1: (-1, 0)
Rotated Endpoint 2: (-2, 1)
In [8]: # Write a python program to find the area and perimeter of the ∆XY Z, where
X(1,2),Y (2,−2), Z(−1,2)
import math
# Input coordinates
X = [1, 2]
Y = [2, -2]
Z = [-1, 2]
# Calculate distances between points
def distance(p1, p2):
return math.sqrt((p2[0] - p1[0]) ** 2 + (p2[1] - p1[1]) ** 2)
# Calculate lengths of sides
XY = distance(X, Y)
YZ = distance(Y, Z)
XZ = distance(X, Z)
# Calculate perimeter
perimeter = XY + YZ + XZ
# Calculate area using Heron's formula
s = perimeter / 2
area = math.sqrt(s * (s - XY) * (s - YZ) * (s - XZ))
# Print results
print("Length of XY: ", XY)
print("Length of YZ: ", YZ)
print("Length of XZ: ", XZ)
print("Perimeter: ", perimeter)
print("Area: ", area)
Length of XY: 4.123105625617661

Length of YZ: 5.0
Length of XZ: 2.0
Perimeter: 11.123105625617661
Area: 4.000000000000003
4/14/24, 10:52 PM slip12
In [10]: # Write a program to solve the following LPP:

# Min Z = 3.5x + 2y
# x ≥4
# y ≤2
# x ≥0,y ≥0
from pulp import *

Z = 3.5 * x + 2 * y
problem+= Z
problem+= x >= 4
problem+= y <= 2
problem.solve()
Status: Optimal
x = 4.0
y = 1.0
4/14/24, 10:52 PM slip12
t [−2,4]
# (I) Refection through Y− axis.
# (III) Scaling in Y−coordinate by factor 4.1.
# (IV) Shearing in X direction by 7/2 units.
import numpy as np
P=np.array([-2,4])
# (I) Refection through Y− axis.
# (II) Scaling in X−coordinate by factor 6
# (IV) Shearing in X direction by 7/2 units.
shearing_x = [P[0] + ((7/2) * P[1]), P[1]]


Scaling in Y-coordinates by factor 4.1: [-2. 16.4]
Shearing in X direction: [12.0, 4]
4/14/24, 10:53 PM slip13
(x) = x3 in [−1,1]

import numpy as np
def f(x):
return x**2
def g(x):
return x**3
y_f=f(x)
y_g=g(x)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.legend()
plt.show()
4/14/24, 10:53 PM slip13
In [2]: # Using Python, plot the surface plot of parabola z = x2 + y2 in −6 < x,y <
6.
import numpy as np
# Generate values for x and y
# Calculate values for z based on the parabola equation
Z = X**2 + Y**2
fig = plt.figure()
# Plot the surface plot
surf = ax.plot_surface(X, Y, Z, cmap='viridis')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Surface Plot of z = x**2 + y**2')
# Show the plot
plt.show()
4/14/24, 10:53 PM slip13
In [4]: # Using sympy declare the points P(5,2),Q(5,−2),R(5,0), check whether these
points are collinear.
# Declare the ray passing through the points P and Q, find the length of th
is ray between P and Q. Also find slope of this ray
from sympy import *

# Declare the points P, Q, and R
P = Point(5, 2)
Q = Point(5, -2)
R = Point(5, 0)
collinear = Point.is_collinear(P, Q, R)
if collinear:
print("Points P, Q, and R are collinear.")
else:
print("Points P, Q, and R are not collinear.")
# Declarethe ray passing through points P and Q
ray_PQ = Ray(P, Q)
# Find the length of the ray between points P and Q
length_PQ = ray_PQ.length
print("Length of ray PQ between points P and Q:", length_PQ)
# Find the slope of the ray PQ
slope_PQ = ray_PQ.slope
print("Slope of ray PQ:", slope_PQ)
Points P, Q, and R are collinear.

Length of ray PQ between points P and Q: oo
Slope of ray PQ: oo
In [5]: # Find the area and perimeter of the ∆ABC, where A[0,0],B[5,0],C[3,3].
import numpy as np
s = (AB + BC + CA) / 2
# Print the results
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275
4/14/24, 10:53 PM slip13

# Max Z = 5x + 3y
# 2x + 5y ≤1
# x ≥0,y ≥0
from pulp import *

Z=5 * x + 3 * y
problem += Z
problem += 2 * x + 5 * y <= 1
problem.solve()
Status: Optimal
Optimal x = 0.5
Optimal y = 0.0
Optimal Z = 2.5
4/14/24, 10:53 PM slip13
t (−2,4) :
import numpy as np
P=np.array([-2,4])
shearing_y1 = [P[0], P[1] + (7 * P[0])]
P_scaled = np.array([P[0] * 7/2, P[1] * 7])
P_sheared = np.array([P[0] + (4 * P[1]), P[1] + (7 * P[0])])

print("Shearing in Y direction:", shearing_y1)
print("Scaling in X and Y direction by 7/2 and 7",P_scaled)
print("Shearing in X and Y direction by 4 and 7 units:",P_sheared)

Scaling in X and Y direction by 7/2 and 7 [-7. 28.]
Shearing in X and Y direction by 4 and 7 units: [ 14 -10]
19]
4/14/24, 10:54 PM slip14
(x) = x3 in [−1,1]
import numpy as np
def f(x):
return x**2
def g(x):
return x**3
y_f=f(x)
y_g=g(x)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.legend()
plt.show()
4/14/24, 10:54 PM slip14
In [2]: # Write a Python program to generate 3D plot of the function z = sin(x) + c

os(y) in −5 < x,y < 5
import numpy as np
# Generate data
# Create 3D plot
fig = plt.figure()
ax.plot_surface(X, Y, Z, cmap='viridis')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('3D Plot of z = sin(x) + cos(y)')
plt.show()
4/14/24, 10:54 PM slip14

and (1,6) and rotate it by 180

import numpy as np
vertices = np.array([[0, 0], [2, 0], [2, 3], [1, 6]])
plt.figure()
plt.plot(vertices[:, 0], vertices[:, 1], 'bo-')
plt.xlabel('X')
plt.ylabel('Y')
# Define the rotation matrix for 180 degrees
theta = np.pi # 180 degrees
rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
# Apply rotation to the vertices
vertices_rotated = np.dot(vertices, rotation_matrix)
plt.figure()
plt.plot(vertices_rotated[:, 0], vertices_rotated[:, 1], 'ro-')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
4/14/24, 10:54 PM slip14
4/14/24, 10:54 PM slip14
In [6]: # Write a Python program to find the area and perimeter of the triangle AB
C, where A[0,0],B[5,0] and C[3,3].
import numpy as np
s = (AB + BC + CA) / 2
# Print the results
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275
4/14/24, 10:54 PM slip14

# Max Z = 150x + 75y
# 5x + 3y ≤15
# x ≥0,y ≥0
from pulp import *

Z= 150*x + 75*y
problem += Z
problem += 4*x + 6*y <=24
problem += 5*x + 3*y <=15
problem.solve()
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
In [8]: # Apply each of the following transformations on the point P[2,−3].

# I. Reflection 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
import numpy as np
P = np.array([2,-3])


Reflection through the line y = x: [-3 2]
4/14/24, 10:55 PM slip15
In [1]: # Write the Python program to find area of the triangle ABC, where A[0,0],B
[5,0],C[3,3]
import math
def calculate_area(x1, y1, x2, y2, x3, y3):
area = abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2)
return area
# Coordinates of vertices A, B, and C
Ax, Ay = 0, 0
Bx, By = 5, 0
Cx, Cy = 3, 3
# Call the function to calculate the area
area = calculate_area(Ax, Ay, Bx, By, Cx, Cy)
# Print the result
print("Area of triangle ABC is:", area)
Area of triangle ABC is: 7.5
4/14/24, 10:55 PM slip15
In [2]: # Write the Python program to plot the graph of the function, using def()
# f(x) = x2 + 4 if −10 ≤x < 5
# 3x + 9 if 5 ≤x < 10
import numpy as np
def f(x):
if -10 < x < 5:
return x**2 + 4
elif 5 <= x:
return 3*x + 9
else:
return None
# Generate x values
# Generate 500 points between -11 and 11
x = np.linspace(-11, 11, 500)
# Calculate y values using f(x)
y = np.array([f(xi) for xi in x])
# Create the plot
plt.plot(x, y, label='f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x)')
plt.legend()
plt.grid(True)
plt.show()
4/14/24, 10:55 PM slip15
In [1]: # Write the Python program to rotate the triangle ABC by 180 degree, where
A[1,2],B[2,−2] & C[−1,2]
import numpy as np
# Define the original triangle vertices
A = np.array([1,2])
B = np.array([2, -2])
C = np.array([-1, 2])
# Rotate the triangle vertices using the rotation matrix
# Print the rotated triangle vertices
print("Original Triangle Vertices:")
print("A:", A)
print("B:", B)
print("C:", C)
print("Rotated Triangle Vertices:")
print("A Rotated:", A_rotated)
print("B Rotated:", B_rotated)
print("C Rotated:", C_rotated)
Original Triangle Vertices:

A: [1 2]
B: [ 2 -2]
C: [-1 2]
Rotated Triangle Vertices:
A Rotated: [-1. -2.]
B Rotated: [-2. 2.]
C Rotated: [ 1. -2.]
4/14/24, 10:55 PM slip15
In [4]: # Write the Python program to plot the graph of function f(x) = ex in the i
nterval [−10,10].
import numpy as np
def f(x):
return np.exp(x)
x = np.linspace(-10, 10, 500)

y = f(x)
plt.plot(x, y, label='f(x) = e**x')

plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x) = e**x')
plt.legend()
plt.grid(True)
plt.show()
4/14/24, 10:55 PM slip15

# Min Z = 3.5x + 2y
# x ≥4
# y ≤2
# x ≥0,y ≥0.
from pulp import *

Z = 3.5 * x + 2 * y
problem+= Z
problem+= x >= 4
problem+= y <= 2
problem.solve()
Status: Optimal
x = 4.0
y = 1.0
4/14/24, 10:55 PM slip15
In [8]: # write a Python program to apply each of the following transformations on

the point P[−2,4].
# I. Reflection through the line y = x + 1.
# II. Scaling in Y -coordinate by factor 1.5.
# III. Shearing in X direction by 2 units.
# IV. Rotation about origin by an angle 45 degrees.
import numpy as np
P=np.array([-2,4])
print("Original Point:")
print("Point P: ({}, {})".format(P[0], P[1]))
# Transformation I: Reflection through the line y = x + 1
reflection_matrix = np.array([[0, 1], [1,0]])
P_reflection = np.dot(reflection_matrix, P)
print("\nPoint after Reflection:")
print("Point P: ({}, {})".format(P_reflection[0], P_reflection[1]))
# Transformation II: Scaling in y-coordinate by factor 1.5

scaling_matrix = np.array([[1, 0], [0, 1.5]])
P_scaling = np.dot(scaling_matrix, P_reflection)
print("\nPoint after Scaling:")
print("Point P: ({}, {})".format(P_scaling[0], P_scaling[1]))
# Transformation III: Shearing in x-direction by 2 units

shearing_matrix= np.array([[1, 2], [0,1]])
P_shearing = np.dot(shearing_matrix, P_scaling)
print("\nPoint after Shearing:")
print("Point P: ({}, {})".format(P_shearing[0], P_shearing[1]))
# Transformation IV: Rotation about origin by an angle of 45 deg

rotation_matrix = np.array([[np.cos(np.pi/4), -np.sin(np.pi/4)], [np.sin(n
p.pi/4), np.cos(np.pi/4)]])
P_rotation = np.dot(rotation_matrix, P_shearing)
print("\nPoint after Rotation:")
print("Point P: ({}, {})".format(P_rotation[0], P_rotation[1]))
Original Point:
Point P: (-2, 4)
Point after Reflection:

Point P: (4, -2)
Point after Scaling:

Point P: (4.0, -3.0)
Point after Shearing:

Point P: (-2.0, -3.0)
Point after Rotation:

Point P: (0.7071067811865477, -3.5355339059327378)
4/14/24, 10:56 PM slip16
In [1]: # Write a Python program to plot graph of the function f(x,y) = –x2 −y2 whe
n −10 ≤x,y ≤10.

import numpy as np
def f(x, y):
return -x**2 - y**2
# Generate x and y values within the range of -10 to 10
x = np.linspace(-10, 10, 100)
y = np.linspace(-10, 10, 100)
# Create a grid of x and y values
# Compute the values of f(x, y) for each (x, y) in the grid
Z = f(X, Y)
# Plot the surface using matplotlib
fig = plt.figure()
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('f(x, y)')
ax.set_title('Graph of f(x, y) = -x**2 - y**2')
plt.show()
4/14/24, 10:56 PM slip16
In [2]: # Write a Python program to generate plot of the function f(x) = x2, in the
interval [−5,5], in figure of size 6 ×6 inches

import numpy as np
def f(x):
return x**2
# Generate x values within the range of [-5, 5]
# Compute the values of f(x) for each x in the range
y = f(x)
# Create a figure with size 6x6 inches
fig = plt.figure(figsize=(6, 6))
# Plot the graph of the function
plt.plot(x, y, label='f(x) = x^2')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x) = x^2')
plt.legend()
plt.show()
4/14/24, 10:56 PM slip16

and (1,6) and rotate it by 90
import numpy as np
vertices = np.array([[0, 0], [2, 0], [2, 3], [1, 6], [0, 0]])
# Plot the original polygon
plt.plot(vertices[:, 0], vertices[:, 1], label='Original Polygon')
# Define the rotation angle in degrees
rotation_angle = 90
# Convert the rotation angle to radians
theta = np.radians(rotation_angle)
# Create the rotation matrix
rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)],[np.sin(theta),
np.cos(theta)]])
# Apply the rotation matrix to the vertices of the polygon

rotated_vertices = np.dot(vertices, rotation_matrix.T)
plt.plot(rotated_vertices[:, 0], rotated_vertices[:, 1], label='Rotated Pol
ygon')
# Set the aspect ratio to 'equal' for a square plot
plt.axis('equal')
plt.legend()
plt.title('Polygon Rotation')
plt.show()
4/14/24, 10:56 PM slip16
In [4]: # Write a Python program to Generate vector x in the interval [0,15] using
numpy package with 100 subintervals
import numpy as np
start = 0
end = 15
# Define the number of subintervals
num_subintervals = 100
# Generate the vector x with equally spaced values in the interval [0, 15]
x = np.linspace(start, end, num=num_subintervals+1)
# Print the generated vector x
print("Generated vector x:")
print(x)
Generated vector x:
[ 0. 0.15 0.3 0.45 0.6 0.75 0.9 1.05 1.2 1.35 1.5 1.65
1.8 1.95 2.1 2.25 2.4 2.55 2.7 2.85 3. 3.15 3.3 3.45
3.6 3.75 3.9 4.05 4.2 4.35 4.5 4.65 4.8 4.95 5.1 5.25
5.4 5.55 5.7 5.85 6. 6.15 6.3 6.45 6.6 6.75 6.9 7.05
7.2 7.35 7.5 7.65 7.8 7.95 8.1 8.25 8.4 8.55 8.7 8.85
9. 9.15 9.3 9.45 9.6 9.75 9.9 10.05 10.2 10.35 10.5 10.65
10.8 10.95 11.1 11.25 11.4 11.55 11.7 11.85 12. 12.15 12.3 12.45
12.6 12.75 12.9 13.05 13.2 13.35 13.5 13.65 13.8 13.95 14.1 14.25
14.4 14.55 14.7 14.85 15. ]

# Min Z = 3.5x + 2y
# x ≥4
# y ≤2
# x ≥0,y ≥0.
from pulp import *

Z = 3.5 * x + 2 * y
problem+= Z
problem+= x >= 4
problem+= y <= 2
problem.solve()
Status: Optimal
x = 4.0
y = 1.0
4/14/24, 10:56 PM slip16
In [7]: # Write a python program to plot the Triangle with vertices at [4,3],[6,3],
[6,5]. and its reflec-tions through, 1) x-axis, 2) y-axis. All the figures
must be in different colors, also plot the two axes

import numpy as np
triangle_vertices = np.array([[4, 3], [6, 3], [6, 5], [4, 3]])

# Reflect the triangle through the x-axis
x_reflected_vertices = np.array([triangle_vertices[:, 0], -triangle_vertice
s[:,
1]]).T
# Reflect the triangle through the y-axis
y_reflected_vertices = np.array([-triangle_vertices[:, 0], triangle_vertice
s[:,
1]]).T
# Plot the original triangle in red color
plt.plot(triangle_vertices[:, 0], triangle_vertices[:, 1], 'r', label='Orig
inalTriangle')
# Plot the x-reflected triangle in blue color
plt.plot(x_reflected_vertices[:, 0], x_reflected_vertices[:, 1], 'b', label
='X-Reflected Triangle')
# Plot the y-reflected triangle in green color
plt.plot(y_reflected_vertices[:, 0], y_reflected_vertices[:, 1], 'g', label
='Y-Reflected Triangle')
# Set the axis labels and title
plt.xlabel('X-axis')
plt.ylabel('Y-axis')
plt.title('Triangle and Its Reflections')
plt.legend()
plt.show()
4/14/24, 10:57 PM slip17
In [1]: #Write python program to plot the 3D graph of the function z = x2 + y2 in

−6 < x,y <6 using surface plot

import numpy as np
# Create a meshgrid for x and y values
# Compute the values of z
Z = X**2 + Y**2
# Create a 3D surface plot
fig = plt.figure()
ax.set_xlabel('X-axis')
ax.set_ylabel('Y-axis')
ax.set_zlabel('Z-axis')
ax.set_title('3D Surface Plot of z = x^2 + y^2')
# Show the plot
plt.show()
4/14/24, 10:57 PM slip17
In [2]: # Write a python program to plot 3D contours for the function f(x,y) = log
(x2y2) when −5 ≤x,y ≤5, with greens color map.

import numpy as np
# Compute the values of f(x, y)
Z = np.log(X**2 * Y**2)
# Create a 3D contour plot
fig = plt.figure()
ax.contour(X, Y, Z, cmap='Greens')
ax.set_zlabel('f(x, y)')
ax.set_title('3D Contour Plot of f(x, y) = log(x^2 * y^2)')
# Show the plot
plt.show()
4/14/24, 10:57 PM slip17
In [3]: # Write a python program to rotate the line segment by 180 degrees having e
nd points (1,0) and (2,−1).

import numpy as np
B = np.array([2, -1])
# Find the midpoint of the line segment
midpoint = (A + B) / 2
rotation_matrix = np.array([[-1, 0],[0, -1]])
# Rotate the end points of the line segment around the midpoint
A_rotated = np.dot(rotation_matrix, A - midpoint) + midpoint
B_rotated = np.dot(rotation_matrix, B - midpoint) + midpoint
# Plot the original line segment and its rotated version
ax.plot([A[0], B[0]], [A[1], B[1]], 'b', label='Original Line Segment AB')
ax.plot([A_rotated[0], B_rotated[0]], [A_rotated[1], B_rotated[1]], 'r',

label='Rotated Line Segment A\'B\'')
ax.scatter(midpoint[0], midpoint[1], color='g', marker='o', label='Midp

oint')
ax.legend()
ax.set_title('Rotation of Line Segment AB by 180 Degrees around Midpoint')
plt.axis('equal')
plt.grid(True)
plt.show()
4/14/24, 10:57 PM slip17
In [4]: # Write a python program to drawn a polygon with vertices (0,0),(1,0),(2,

2),(1,4) and find its area and perimeter.

import numpy as np
# Define the vertices of the polygon
# Extract x and y coordinates of the vertices
x = vertices[:, 0]
y = vertices[:, 1]
# Plot the polygon
ax.plot(x, y, 'b', label='Polygon')
# Calculate the area of the polygon
area = 0.5 * np.abs(np.dot(x, np.roll(y, 1)) - np.dot(y, np.roll(x, 1)))
# Calculate the perimeter of the polygon
perimeter = np.sum(np.sqrt(np.diff(x) ** 2 + np.diff(y) ** 2))
# Print the calculated area and perimeter
print("Area of the polygon: ", area)
print("Perimeter of the polygon: ", perimeter)
ax.set_title('Polygon with Vertices (0, 0), (1, 0), (2, 2), (1, 4)')
ax.legend()
plt.grid(True)
plt.show()
Area of the polygon: 4.0

Perimeter of the polygon: 9.595241580617241
4/14/24, 10:57 PM slip17

# Max Z = 4x + y + 3z + 5w
# subject to 4x + 6y −5z −4w ≥−20
# −8x −3y + 3z + 2w ≤20
# x ≥0,y ≥0.
from pulp import *

# Create the LP problem
lp_problem = LpProblem("Minimize Z", LpMaximize)
z = LpVariable('z', lowBound=0, cat='Continuous')
w = LpVariable('w', lowBound=0, cat='Continuous')
# Set the objective function
Z= 4*x + y + 3*z + 5*w
lp_problem += Z
# Add the constraints
lp_problem += 4*x + 6*y - 5*z - 4*w >= -20
lp_problem += -8*x - 3*y + 3*z + 2*w <= 5
lp_problem += x >= 0
lp_problem += y >= 0
lp_problem.solve()
# Print the status of the LP problem
print("Status: ", LpStatus[lp_problem.status])
# Print the optimal values of the decision variables
print("Optimal Values:")
print("x = ", x.varValue)
print("y = ", y.varValue)
print("z = ", z.varValue)
print("w = ", w.varValue)
print("Optimal Objective Function Value = ", value(lp_problem.objective))
Status: Unbounded
Optimal Values:
x = 0.83333333
y = 0.0
z = 0.0
w = 5.8333333
Optimal Objective Function Value = 32.49999982
4/14/24, 10:57 PM slip17
In [1]: # Apply each of the following transformations on the point P[3,−1].

# I. Reflection through X-axis.
# II. Scaling in Y-coordinate by factor 1.5.
# III. Shearing in both X and Y direction by -2 and 4 units respectively.
# IV. Rotation about origin by an angle 30 degrees
import numpy as np
P = np.array([2, -3])
# (I) Reflection through X-axis
reflection_X = np.array([[1, 0],[0, -1]])
P_reflection_X = np.dot(reflection_X, P)
# (II) Scaling in Y-coordinate by factor 1.5
scaling_Y = np.array([[1, 0],[0, 1.5]])
P_scaling_Y = np.dot(scaling_Y, P)
# (III) Shearing in both X and Y direction by -2 and 4 units respectively
# (IV) Rotation about origin by an angle of 30 degrees
rotation = np.array([[np.cos(angle), -np.sin(angle)],[np.sin(angle),
np.cos(angle)]])
P_rotation = np.dot(rotation, P)
# Print the results
print("Original Point P:", P)
print("Result after reflection through X-axis:", P_reflection_X)
print("Result after scaling in Y-coordinate by factor 1.5:", P_scaling_Y)
print("Result after shearing in both X and Y direction by -2 and
4 units respectively:", P_sheared)
print("Result after rotation about origin by an angle of 30 degrees:", P_ro
tation)
Original Point P: [ 2 -3]

Result after reflection through X-axis: [2 3]
Result after scaling in Y-coordinate by factor 1.5: [ 2. -4.5]
Result after shearing in both X and Y direction by -2 and 4 un
its respectively: [[ 2 6]
[ 8 -3]]
Result after rotation about origin by an angle of 30 degrees: [ 3.23205081
-1.59807621]
4/14/24, 11:01 PM slip18
In [2]: # Write a Python program to plot the graph 2x2 −4x + 5 in [–10,10] in magen
ta colored dashed pattern
import numpy as np

def f(x):
return 2*x**2 - 4*x + 5
# Generate x values
x = np.linspace(-10, 10, 400)
# Generate y values
y = f(x)
# Plot the graph

plt.plot(x, y, color='magenta', linestyle='dashed', label='2x^2 - 4x + 5')
# Add labels and title

plt.xlabel('x')
plt.ylabel('y')
plt.title('Graph of $2x^2 - 4x + 5$')
plt.grid(True)
plt.legend()
plt.show()
https://htmtopdf.herokuapp.com/ipynbviewer/temp/495099c9ac217b4c29128029f1abe805/slip18.html?t=1713115836845 1/5
4/14/24, 11:01 PM slip18
In [3]: # Write a Python program to generate 3D plot of the functions z = x2 + y2 i

n −5 < x,y < 5
import numpy as np
# Create a grid of x, y values
# Compute the corresponding z values using the function z = x^2 + y^2
Z = X**2 + Y**2
fig = plt.figure()
# Plot the surface
# Set labels for x, y, and z axes
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
# Set title
ax.set_title('3D Plot of z = x^2 + y^2')
# Show the plot
plt.show()
4/14/24, 11:01 PM slip18
In [9]: # Write a Python program to generate vector x in the interval [−22,22] usin
g numpy package with 80 subintervals
import numpy as np
start = -22
end = 22
x = np.linspace(start, end ,num = num_subintervals+1)

print(x)
[-22. -21.45 -20.9 -20.35 -19.8 -19.25 -18.7 -18.15 -17.6 -17.05
-16.5 -15.95 -15.4 -14.85 -14.3 -13.75 -13.2 -12.65 -12.1 -11.55
-11. -10.45 -9.9 -9.35 -8.8 -8.25 -7.7 -7.15 -6.6 -6.05
-5.5 -4.95 -4.4 -3.85 -3.3 -2.75 -2.2 -1.65 -1.1 -0.55
0. 0.55 1.1 1.65 2.2 2.75 3.3 3.85 4.4 4.95
5.5 6.05 6.6 7.15 7.7 8.25 8.8 9.35 9.9 10.45
11. 11.55 12.1 12.65 13.2 13.75 14.3 14.85 15.4 15.95
16.5 17.05 17.6 18.15 18.7 19.25 19.8 20.35 20.9 21.45
22. ]
In [11]: # Write a Python program to rotate the triangle ABC by 90 degree, where A
[1,2],B[2,−2]andC[−1,2]
import numpy as np
B = np.array([2, -2])
C = np.array([-1, 2])
# Define the rotation matrix for rotation by 90 degrees counter clockwise


Rotated Point C: [-2. -1.]
4/14/24, 11:01 PM slip18
In [16]: # write a Python program to solve the following LPP:

# Min Z = x + y
# subject to x ≥6
# y ≥6
# x + y ≤11
# x ≥0,y ≥0
from pulp import *

Z = x + y
problem+= Z
problem+= x >= 6
problem+= y >= 6
problem+= x + y <=11
problem.solve()
if problem.status==LpStatusOptimal:
Status: Infeasible
4/14/24, 11:01 PM slip18
In [ ]: # Apply each of the following transformations on the point P[3,−1].

# I. Reflection through Y-axis.
# II. Scaling in X and Y direction by 1/2 and 3 units respectively.
# III. Shearing in both X and Y direction by -2 and 4 units respectively.
# IV. Rotation about origin by an angle 60 degrees.
import numpy as np
# Define the point P

P = np.array([3, -1])
# I. Reflection through Y-axis

P_reflected = np.array([-P[0], P[1]])
# II. Scaling in X and Y direction by 1/2 and 3 units respectively

P_scaled = np.array([P[0] * 0.5, P[1] * 3])
# III. Shearing in both X and Y direction by -2 and 4 units respectively

# IV. Rotation about origin by an angle 60 degrees
rotation_matrix = np.array([[np.cos(np.pi/3), -np.sin(np.pi/3)], [np.sin(n

p.pi/3), np.cos(np.pi/3)]])
P_rotated = np.dot(rotation_matrix, P)
# Print the results

print("I. Reflection through Y-axis:", P_reflected)
print("II. Scaled point:", P_scaled)
print("III. Sheared point:", P_sheared)
print("IV. Rotated point:", P_rotated)
4/14/24, 11:02 PM slip19
4/14/24, 11:02 PM slip19
In [9]: # Write a python program to plot the graphs of sin(x),ex and x3 in [0,5] in
one figure with 2 ×2 subplots
import numpy as np
# Define the range

# Calculate the functions

y1 = np.sin(x)
y2 = np.exp(x)
y3 = x**3
# Create subplots
plt.figure(figsize=(10, 8))
plt.subplot(2, 2, 1)
plt.plot(x, y1, 'r')
plt.title('sin(x)')
plt.plot(x, y2, 'g')
plt.title('exp(x)')
plt.plot(x, y3, 'b')
plt.title('x^3')
# Adjustbspacing between subplots
plt.tight_layout()
plt.show()
4/14/24, 11:02 PM slip19
In [10]: # Write a python program to plot 2D graph of the functions f(x) = log(x) +
5 and g(x) = log(x) −5 in [0,10] by setting different line width and differ
ent colors to the curve
import numpy as np
# Define the functions
def f(x):
return np.log(x) + 5
def g(x):
return np.log(x) - 5
# Generate x values in the range [0, 10]

x = np.linspace(0.01, 10, 100)
# Compute y values for f(x) and g(x)
y_f = f(x)
y_g = g(x)
# Create the plot
plt.plot(x, y_f, label='f(x) = log(x) + 5', linewidth=2, color='blue')
plt.plot(x, y_g, label='g(x) = log(x) - 5', linewidth=1, color='red')
# Add labels and legend
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.title('2D Graph of f(x) and g(x)')
plt.show()
4/14/24, 11:02 PM slip19
In [11]: # Write a python program to rotate the ray by 90o in clockwise direction ha
ving starting point (0,0) and end point (4,4).
import math
x1, y1 = 0, 0
x2, y2 = 4, 4
# Perform the rotation
x1_rotated = -x1
y1_rotated = -y1
x2_rotated = -x2
y2_rotated = -y2
# Print the original and rotated endpoints

Rotated Endpoint 1: (0, 0)
Rotated Endpoint 2: (-4, -4)
4/14/24, 11:02 PM slip19
In [13]: # Write a Python program to Reflect the triangle ABC through the line y=3,
where A[1,0],B[2,−1] and C[−1,3]
import numpy as np
# Define vertices of the triangle ABC

B = np.array([2, -1])
C = np.array([-1, 3])
# Define the equation of the reflection line y = 3

line = 3
# Reflect each vertex across the reflection line

A_reflected = np.array([A[0], 2 * line - A[1]])
B_reflected = np.array([B[0], 2 * line - B[1]])
C_reflected = np.array([C[0], 2 * line - C[1]])
# Plot the original triangle ABC

plt.plot([A[0], B[0], C[0], A[0]], [A[1], B[1], C[1], A[1]], 'b-', label='T
riangle ABC')
# Plot the reflection of triangle ABC

plt.plot([A_reflected[0], B_reflected[0], C_reflected[0], A_reflected[0]],
[A_reflected[1], B_reflected[1], C_reflected[1], A_reflected[1]], 'r-', lab
el='Reflected Triangle')
# Plot the reflection line

plt.axhline(y=line, color='g', linestyle='--', label='Reflection Line y=3')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Reflection of Triangle ABC through the line y=3')
plt.legend()
plt.grid(True)
plt.show()
4/14/24, 11:02 PM slip19
4/14/24, 11:02 PM slip19

# Max Z = 3x + 5y + 4z
# 2y + 5z ≤10
# 3x + 2y + 4z ≤15
# x ≥0,y ≥0
from pulp import *

# Create the LP prob
prob = LpProblem("Minimize Z", LpMaximize)

Z= 3*x + 5*y + 4*z
prob += Z
prob += 2*x + 3*y <= 8
prob += 2*y + 5*z <= 10
prob += 3*x + 2*y + 4*z <= 15
# Solve the LP prob
prob.solve()
# Print the status of the LP prob
print("Status: ", LpStatus[prob.status])
print("Optimal Objective Function Value = ", value(prob.objective))
Status: Optimal
Optimal Values:
x = 2.1707317
y = 1.2195122
z = 1.5121951
4/14/24, 11:02 PM slip19
In [19]: # Find combined transformation of the line segment between the points A
[4,−1] and B[3,0] for
# the following sequence of transformations:
# First rotation about origin through an angle πc; followed by scaling in x
coordinate by 3 units;
# followed by reflection through the line y = x.
A = np.array([4, -1])
# Transformation 1: Rotation about origin through an angle pi (180 degrees)
angle = np.pi
rotation_matrix = np.array([[np.cos(angle), -np.si(angle)], [np.sin(angle),
np.cos(angle)]])
rotated_A = np.dot(rotation_matrix, A)
rotated_B = np.dot(rotation_matrix, B)
# Transformation 2: Scaling in x-coordinate by 3 units
scaling_factor = np.array([[3, 0],
[0, 1]])
scaled_A = np.dot(scaling_factor, rotated_A)
scaled_B = np.dot(scaling_factor, rotated_B)
# Transformation 3: Reflection through the line y = x
reflection_matrix = np.array([[0, 1],
[1, 0]])
reflected_A = np.dot(reflection_matrix, scaled_A)
reflected_B = np.dot(reflection_matrix, scaled_B)
# Print the results
print("Initial Points A and B:")
print("A =", A)
print("B =", B)
print("Combined Transformed Points A and B:")
print("A' =", reflected_A)
print("B' =", reflected_B)
Initial Points A and B:

A = [ 4 -1]
B = [3 0]
Combined Transformed Points A and B:
A' = [ 1. -12.]
B' = [ 3.6739404e-16 -9.0000000e+00]
slip20
April 14, 2024
[2]: # Write a Python program to plot 2D graph of the function f(x) = sin x and g(x)␣
↪= cos x in [−2�,2�]
import numpy as np
def f(x):
return np.sin(x)
def g(x):
return np.cos(x)
x = np.linspace(-2*np.pi , 2*np.pi , 100)

# Compute y values for f(x) and g(x)
y_f = f(x)
y_g = g(x)
# Create the plot
plt.plot(x, y_f, label='f(x) = sin(x)', linewidth=2, color='blue')
plt.plot(x, y_g, label='g(x) = cos(x)', linewidth=1, color='red')
# Add labels and legend
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.title('2Grap of f(x) = sin(x) and g(x)=cos(x)')
plt.show()
1
[7]: # Write a Python program to plot the 2D graph of the function f(x) = ex sin x␣
↪in [−5�,5�] with blue points line with upward pointing triangle
import numpy as np
def f(x):
return np.exp(x) * np.sin(x)
x = np.linspace(-5*np.pi, 5*np.pi, 500)
y = f(x)
plt.plot(x, y, 'r^-', linewidth=1)

# Set x and y axis labels
plt.xlabel('x')
plt.ylabel('f(x)')
# Set the title of the graph
plt.title('2D Graph of f(x) = e^(x) * sin(x)')
# Show the graph
2
plt.show()
[8]: # Write a python program to reflect the line segment joining the points␣
↪A[−5,2],B[3,−4] through the line y = 2x −1
# Points A and B
A = (-5, 2)
B = (3, -4)
# Reflection line y = 2x - 1
# Calculating the slope of the reflection line

m = 2
# Calculating the perpendicular slope

m_perpendicular = -1/m
# Calculating the y-intercept of the reflection line
b = 2 * 0 - 1
# Function to find the reflection of a point through a line
3
def reflect_point(point):
x, y = point
x_reflect = (m * (y - b) + x) / (m**2 + 1)
y_reflect = m * x_reflect + b
return (x_reflect, y_reflect)
# Reflecting points A and B through the line

A_reflected = reflect_point(A)
B_reflected = reflect_point(B)
# Output
print("Reflection of point A:", A_reflected)
print("Reflection of point B:", B_reflected)
Reflection of point A: (0.2, -0.6)

Reflection of point B: (-0.6, -2.2)
[9]: # Write a Python program to plot the 3D graph of the function f(x,y) = sin␣
↪x+cos y, x,y �[−2�,2�] using wireframe plot.
import numpy as np
x = np.linspace(-2 * np.pi, 2 * np.pi, 100)

y = np.linspace(-2 * np.pi, 2 * np.pi, 100)
# Create a meshgrid from x and y
# Calculate the Z values using the function f(x, y) = sin(x) + cos(y)
# Create a 3D plot
fig = plt.figure()
# Create a wireframe plot
ax.plot_wireframe(X, Y, Z)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('3D Wireframe Plot of f(x, y) = sin(x) + cos(y)')
# Show the plot
plt.show()
4
[11]: # Write a Python program to solve the following LPP:
# Max Z = x + y
# subject to x −y �1
# x + y �2
# x �0,y �0
from pulp import *
problem= LpProblem("Maximize Z", LpMaximize)

Z = x + y
problem+= Z
problem+= x - y >= 1
problem.solve()
5
Status: Unbounded
x = 0.0
y = 0.0
[12]: # Apply the following transformations on the point P[3,−2]

# I. Shearing in x direction by -2 units.
# II. Scaling in x and y direction by -3 and 2 units respectively.
# III. Reflection through x axis.
# IV. Reflection through the line y = −x.
import numpy as np
P=np.array([3,-2])
# I. Shearing in x direction by -2 units.
shearing_x = [P[0] + ((-2) * P[1]), P[1]]
# II. Scaling in x and y direction by -3 and 2 units respectively.
scaling_x = np.array([-3, 1]) * P
# III. Reflection through x axis.
# IV. Reflection through the line y = −x.

print("Shearing in X direction by -2 unit:", shearing_x)
print("Scaling in X-coordinates by factor -3:", scaling_x)

Shearing in X direction by -2 unit: [7, -2]
Scaling in X-coordinates by factor -3: [-9 -2]
Scaling in Y-coordinates by factor 2: [ 3 -4]
Reflection through the line y = x: [ 2 -3]
6
slip21
April 14, 2024
[2]: # Write a Python program to plot 2D graph of the function f(x) = x4 in [0,5]␣
↪with red dashed line with circle markers
import numpy as np
def f(x):
return x**4
y = f(x)
# Plot the graph with red dashed line and circle markers
plt.plot(x, y, 'r--o')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x) = x**4')
plt.show()
1
[6]: # Write a Python program to plot the 3D graph of the function f(x) = ex2+y2
# for x,y �[0,2�] using wireframe
import numpy as np

y = np.linspace(0, 2 * np.pi, 100)
# Create a meshgrid from x and y
# Calculate the Z values using the function f(x, y) = exp(x**2+y**2)
Z = np.exp( X**2 + Y**2 )
# Create a 3D plot
fig = plt.figure()
# Create a wireframe plot
ax.plot_wireframe(X, Y, Z,rstride=5,cstride=5)
ax.set_xlabel('X')
2
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('3D Wireframe Plot of f(x, y) = exp(x**2+y**2)')
# Show the plot
plt.show()
[7]: # If the line segment joining the points A[2,5] and B[4,−13] is transformed to␣
↪the line segment A�B� by the transformation matrix [T] =[2 3
# 4 1]
# then using python find the slope and midpoint of the transformed line
A = [2, 5]
B = [4, -13]
# Transformation matrix
T = [[2, 3],
[4, 1]]
# Function to multiply matrix and vector

def matrix_mult(matrix, vector):
result = [0, 0]
for i in range(len(matrix)):
3
for j in range(len(vector)):
result[i] += matrix[i][j] * vector[j]
return result
# Apply transformation matrix to points A and B

A_trans = matrix_mult(T, A)
B_trans= matrix_mult(T, B)
# Calculate slope
slope=(B_trans[1] - A_trans[1]) / (B_trans[0] - A_trans[0])
# Calculate midpoint
midpoint = [(A_trans[0] + B_trans[0]) / 2, (A_trans[1] + B_trans[1]) / 2]
print("Transformed point A':", A_trans)

print("Transformed point B':", B_trans)
print("Slope of transformed line segment:", slope)
print("Midpoint of transformed line segment:", midpoint)
Transformed point A': [19, 13]

Transformed point B': [-31, 3]
Slope of transformed line segment: 0.2
Midpoint of transformed line segment: [-6.0, 8.0]
[9]: # Write a python program to plot square with vertices at␣

↪[4,4],[2,4],[2,2],[4,2] and find its uniform expansion by factor 3, uniform␣
↪reduction by factor 0.4.
import numpy as np
# Plot the original square
ax.plot(vertices[:, 0], vertices[:, 1], 'b-o', label='Original Square')
# Define the uniform expansion and reduction factors
expans_fac = 3
reduct_fac = 0.4
# Perform uniform expansion
expanded_ver= vertices * expans_fac
# Perform uniform reduction
reduced_ver= vertices * reduct_fac
# Plot the expanded and reduced squares
ax.plot(expanded_ver[:, 0],expanded_ver[:, 1], 'r-o',label='Uniform␣
↪Expansion')
ax.plot(reduced_ver[:, 0],reduced_ver[:, 1], 'g-o', label='Uniform Reduction')

# Set axis labels and title
4
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Uniform Expansion and Reduction of a Square')
ax.legend()
plt.grid()
# Set aspect ratio to 'equal' for a square plot
ax.set_aspect('equal')
plt.show()

# Max Z = 2x + 4y
# subject to 2x + y �18
# 2x + 2y �30
# x + 2y = 26
# x �0,y �0
from pulp import *
problem= LpProblem("Maximize Z", LpMaximize)

5
Z = 2*x + 4*y
problem+= Z
problem+= 2*x + y <=18

problem+= 2*x + 2*y >=30
problem+= x + 2*y >= 26
problem+= x + 2*y <= 26
problem.solve()
Status: Infeasible
x = 3.0
y = 12.0
[12]: # Apply the following transformations on the point P[−2,4].

# I. Shearing in Y direction by 7 units.
# II. Scaling in both X and Y direction by 4 and 7 units respectively.
# III. Rotation about origin by an angle 48 degrees.
# IV. Reflection through line y = x.
import numpy as np
P=np.array([-2,4])
# I. Shearing in Y direction by 7 units
shearing_y = [P[0], P[1] + (7 * P[0])]
# II. Scaling in both X and Y direction by 4 and 7 units respectively.
scaling_both = np.array([[4, 0],[0, 7]])
P_scaling_both = np.dot(scaling_both, P)
# III. Rotation about origin by an angle 48 degrees
rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.
↪cos(angle)]])
P_rotated = np.dot(rotation_matrix, P)
# IV. Reflection through line y = x.

print("Shearing in Y direction:", shearing_y)
print("Scaling in both X and Y direction by 4 and 7 units:", P_scaling_both)
print("Rotation about origin by an angle 48 degrees:",P_rotated)
6

Scaling in both X and Y direction by 4 and 7 units: [-8 28]
Rotation about origin by an angle 48 degrees: [-4.31084051 1.19023277]
Reflection through the line y = x: [ 4 -2]
7
slip22
April 14, 2024
[1]: # Write a python program to draw 2D plot y = log(x2) + sin(x) with suitable␣
↪label in the x axis , y
# axis and a title in [−5�,5�]
import numpy as np
x = np.linspace(-5 * np.pi, 5 * np.pi, 500)
y = np.log(x**2) + np.sin(x)
plt.plot(x, y)
plt.xlabel('x-axis Label')
plt.ylabel('y-axis Label')
plt.title('2D Plot of y = log(x^2) + sin(x)')
plt.show()
1
[5]: # Write a python program to draw 2D plot y = xsin( 1 / x2) in [−5,5] with␣
↪suitable label in the x axis,y axis, a title and location of legend to lower␣
↪right corner
import numpy as np
y = x * np.sin(1 / x**2)
plt.plot(x, y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('2D Plot of y = x * sin(1/x^2)')
plt.show()
[6]: # Write a python program to find the angle at each vertices of the triangle ABC␣
↪where A[0,0],B[2,2] and C[0,2].
2
import numpy as np
AC = np.linalg.norm(C - A)
angle_A = np.arccos((AB**2 + AC**2 - BC**2) / (2 * AB * AC))

angle_B = np.arccos((-AB**2 + AC**2 + BC**2) / (2 * AC * BC))
angle_C = np.pi - angle_A - angle_B
angle_A_deg = np.degrees(angle_A)
angle_B_deg = np.degrees(angle_B)
angle_C_deg = np.degrees(angle_C)
print("Angle at vertex A: {:.2f} degrees".format(angle_A_deg))

print("Angle at vertex B: {:.2f} degrees".format(angle_B_deg))
print("Angle at vertex C: {:.2f} degrees".format(angle_C_deg))
Angle at vertex A: 45.00 degrees

Angle at vertex B: 90.00 degrees
Angle at vertex C: 45.00 degrees
[7]: # Write a Python program to find area and perimeter of the triangle ABC where␣
↪A[0,0],B[5,0],C[3,3].
import numpy as np
s = (AB + BC + CA) / 2
3
Triangle ABC:
Side AB: 5.0
Side BC: 3.605551275463989
Side CA: 4.242640687119285
Area: 7.5000000000000036
Perimeter: 12.848191962583275

# Min Z = x + y
# subject to x + y �11
# x �6
# y �6
# x �0,y �0.
from pulp import *

Z = x + y
problem+= Z
problem+= x + y <=11
problem+= x >= 6
problem+= y >= 6
problem.solve()
Status: Infeasible
x = 6.0
y = 6.0
[1]: # Write the Python program for each of the following.

# I. Rotate the point (1,1) about (1,4) through angle �/2.
# II. Find Distance Between two points (0,0) and (1,0)
# III. Find the shearing of the point (3,4) in X direction by 3 units.
# IV. Represent two dimensional points using point function (−2,5)
import math
4
def rotate_point(x, y, cx, cy, theta):
x_new = cx + (x - cx) * math.cos(theta) - (y - cy) * math.sin(theta)
y_new = cy + (x - cx) * math.sin(theta) + (y - cy) * math.cos(theta)
return x_new, y_new
def distance_between_points(x1, y1, x2, y2):

return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
def shear_point_x(x, y, shear_factor):

x_new = x + shear_factor * y
y_new = y
return x_new, y_new
def create_point(x, y):

return x, y
# Task I: Rotate the point (1,1) about (1,4) through angle �/2
rotated_point = rotate_point(1, 1, 1, 4, math.pi/2)
print("Rotated point:", rotated_point)
# Task II: Find distance between two points (0,0) and (1,0)
distance = distance_between_points(0, 0, 1, 0)
print("Distance between points:", distance)
# Task III: Find the shearing of the point (3,4) in X direction by 3 units
sheared_point = shear_point_x(3, 4, 3)
print("Sheared point:", sheared_point)
# Task IV: Represent two-dimensional points using point function (-2,5)

point = create_point(-2, 5)
print("2D point:", point)
Rotated point: (4.0, 4.0)

Distance between points: 1.0
Sheared point: (15, 4)
2D point: (-2, 5)
5
slip23
April 14, 2024
[1]: # Write a python program plot the graphs of sin x,and cos x in [0,�] in one␣
↪figure with 2 ×1 subplots
import numpy as np
# Generate x values from 0 to �

x = np.linspace(0, np.pi, 100)
# Calculate y values for sin(x) and cos(x)

y_sin = np.sin(x)
y_cos = np.cos(x)
# Create subplots
fig, (ax1, ax2) = plt.subplots(2, 1)
# Plot sin(x)
ax1.plot(x, y_sin, label='sin(x)', color='blue')
ax1.set_title('sin(x)')
ax1.set_xlabel('x')
ax1.set_ylabel('sin(x)')
ax1.legend()
# Plot cos(x)
ax2.plot(x, y_cos, label='cos(x)', color='red')
ax2.set_title('cos(x)')
ax2.set_xlabel('x')
ax2.set_ylabel('cos(x)')
ax2.legend()
# Adjust layout to prevent overlap

plt.tight_layout()
# Show plot
plt.show()
1
[2]: # Write a python program to Plot the graph of the following functions in the␣
↪given interval.
# i. f(x) = x3 in [0,5].
# ii. f(x) = x2 in [−2,2]
import numpy as np
def f1(x):
return x**3
def f2(x):
return x**2
x1 = np.linspace(0, 5, 100)
x2 = np.linspace(-2, 2, 100)
# Calculate y values for the functions
y1 = f1(x1)
y2 = f2(x2)
# Create a figure with two subplots side by side
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
2
# Plot f(x) = x^3 in the first subplot
axs[0].plot(x1, y1, label='f(x) = x^3')
axs[0].set_xlabel('x')
axs[0].set_ylabel('f(x)')
axs[0].set_title('f(x) = x^3 in [0, 5]')
axs[0].legend()
# Plot f(x) = x^2 in the second subplot
axs[1].plot(x2, y2, label='f(x) = x^2')
axs[1].set_xlabel('x')
axs[1].set_ylabel('f(x)')
axs[1].set_title('f(x) = x^2 in [-2, 2]')
axs[1].legend()
# Add overall title to the figure
fig.suptitle('Graphs of f(x) = x^3 and f(x) = x^2')
# Adjust spacing between subplots
plt.tight_layout()
# Show the plot
plt.show()
[3]: # Write a Python program to draw regular polygon with 20 sides and radius 1␣
↪centered at (0,0)
import numpy as np
# Number of sides of the polygon
n = 20
# Radius of the polygon
radius = 1
3
# Generate angles for the vertices of the polygon
angles = np.linspace(0, 2 * np.pi, n + 1)[:-1]
# Calculate x and y coordinates for the vertices of the polygon
x = radius * np.cos(angles)
y = radius * np.sin(angles)
# Create a figure
# Plot the regular polygon
ax.plot(x, y, 'b-o', linewidth=2, markersize=8)
ax.set_aspect('equal', 'box')
ax.set_title(f'Regular Polygon with {n} sides')
ax.set_xlabel('x')
ax.set_ylabel('y')
# Show the plot
plt.show()
[6]: # Write a Python program to find area and perimeter of triangle ABC where␣
↪A[0,1],B[−5,0] and C[−3,3].
import math
import numpy as np
4
B = np.array([-5, 0])
C = np.array([-3, 3])
s = (AB + BC + CA) / 2
Triangle ABC:
Side AB: 5.0990195135927845
Side BC: 3.605551275463989
Side CA: 3.605551275463989
Area: 6.500000000000002
Perimeter: 12.310122064520764

# Max Z = 3x + 5y + 4z
# subject to 2x + 3y �8
# 2x + 5y �10
# 3x + 2y + 4z �15
# x,y,z �0.
from pulp import *

# Create the LP prob
prob = LpProblem("Minimize Z", LpMaximize)

Z= 3*x + 5*y + 4*z
prob += Z
prob += 2*x + 3*y <= 8
5
prob += 2*y + 5*z <= 10
prob += 3*x + 2*y + 4*z <= 15
# Solve the LP prob
prob.solve()
# Print the status of the LP prob
print("Status: ", LpStatus[prob.status])
print("Optimal Objective Function Value = ", value(prob.objective))
Status: Optimal
Optimal Values:
x = 2.1707317
y = 1.2195122
z = 1.5121951
[11]: # Write the Python program to apply each of the following transformation on the␣
↪point P =
# [3,−1].
# I. Reflection through X axis.
# II. Rotation about origin by an angle 30 degrees.
# III. Scaling in Y coordinate by factor 8.
# IV. Shearing in X direction by 2 units
import numpy as np
P=np.array([3,-1])
# I. Reflection through X axis.
# II. Rotation about origin by an angle 30 degrees.
# III. Scaling in Y coordinate by factor 8
# IV. Shearing in X direction by 2 units
shearing_x = [P[0] + (2 * P[1]), P[1]]
6
Rotation about origin through an angle of 30 degree: [3.09807621 0.6339746 ]
Scaling in Y-coordinates by factor 8: [ 3 -8]
Shearing in X direction: [1, -1]
7
slip24
April 14, 2024
[1]: # write the Python program to plot the graph of the function, using def()
#
#f(x) = x2 + 4 if −10 �x < 5
# 3x + 9 if 5 �x < 10
import numpy as np
def f(x):
if -10 < x < 5:
return x**2 + 4
elif 5 <= x:
return 3*x + 9
else:
return None
# Generate x values
# Generate 500 points between -11 and 11
x = np.linspace(-11, 11, 500)
# Calculate y values using f(x)
y = np.array([f(xi) for xi in x])
# Create the plot
plt.plot(x, y, label='f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Graph of f(x)')
plt.legend()
plt.grid(True)
plt.show()
1
[4]: # Write a Python program to plot graph of the function f(x) = log(3x2), in␣
↪[1,10] with black dashed points.
import numpy as np
def f(x):
return np.log(3 * x**2)

y = f(x)
# Create a plot
plt.plot(x, y, 'k--', marker='o', markersize=6)
plt.xlabel('X')
plt.ylabel('f(x)')
plt.title('Plot of f(x) = log(3x^2)')
plt.show()
2
[5]: # Write a Python program to generate vector x in the interval [−22,22] using␣
↪numpy package with 80 subintervals
import numpy as np
start = -22
end = 22
x = np.linspace(start, end ,num = num_subintervals+1)

print(x)
[-22. -21.45 -20.9 -20.35 -19.8 -19.25 -18.7 -18.15 -17.6 -17.05
-16.5 -15.95 -15.4 -14.85 -14.3 -13.75 -13.2 -12.65 -12.1 -11.55
-11. -10.45 -9.9 -9.35 -8.8 -8.25 -7.7 -7.15 -6.6 -6.05
-5.5 -4.95 -4.4 -3.85 -3.3 -2.75 -2.2 -1.65 -1.1 -0.55
0. 0.55 1.1 1.65 2.2 2.75 3.3 3.85 4.4 4.95
5.5 6.05 6.6 7.15 7.7 8.25 8.8 9.35 9.9 10.45
11. 11.55 12.1 12.65 13.2 13.75 14.3 14.85 15.4 15.95
3
16.5 17.05 17.6 18.15 18.7 19.25 19.8 20.35 20.9 21.45
22. ]
[6]: # Write a python program to plot triangle with vertices [3,3],[5,6],[5,2], and␣
↪its rotation about the origin by angle −� radians
import numpy as np
v1 = np.array([3, 3])
v2 = np.array([5, 6])
v3 = np.array([5, 2])
theta = -np.pi
R = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
v1_rotated = np.dot(R, v1)

plt.figure()
plt.plot([v1[0], v2[0], v3[0], v1[0]], [v1[1], v2[1], v3[1], v1[1]], 'b-',␣

↪label='Original Triangle')
plt.
↪plot([v1_rotated[0],v2_rotated[0],v3_rotated[0],v1_rotated[0]],[v1_rotated[1],␣
↪v2_rotated[1], v3_rotated[1], v1_rotated[1]], 'r-', label='Rotated␣

↪Triangle')
plt.plot(0, 0, 'ko', label='Origin')

plt.xlabel('X')
plt.ylabel('Y')
plt.title('Triangle Rotation')
plt.legend()
# Show the plot
plt.show()
4
# Min Z = 3.5x + 2y
# subject to x + y �5
# x �4
# y �2
# x �0,y �0
from pulp import *

Z = 3.5 * x + 2 * y
problem+= Z
problem+= x >= 4
problem+= y <= 2
5
problem.solve()
Status: Optimal
x = 4.0
y = 1.0
[9]: # Apply Python program in each of the following transformations on the point␣
↪P[3,−1]
# 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.
import numpy as np
P=np.array([3,-1])
# 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.


Reflection through the line y = x: [-1 3]
6
slip25
April 14, 2024
[1]: # Using Python plot the surface plot of function z = cos (x2 + y2 −0.5)in the␣
↪interval from −1 < x,y < 1.
import numpy as np
def func(x, y):

return np.cos(x**2 + y**2 - 0.5)
# Generate x, y values in the interval from -1 to 1
# Create a 3D plot
fig = plt.figure()
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Surface Plot of z = cos(x**2 + y**2 - 0.5)')
plt.show()
1
[4]: # Using Python plot the graph of function f(x) = sin−1(x) on the interval [−1,1]
import numpy as np
x = np.linspace(-1, 1, 1000)
# Calculate f(x) values
f_x = np.arcsin(x)
# Create the plot
plt.plot(x, f_x)
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('Plot of f(x) = sin^-1(x)')
plt.grid(True)
plt.axhline(0, color='black') # Add horizontal grid line at y=0
plt.show()
2
[5]: # Rotate the line segment by 180◦ having end points (1,0) and (2,−1)
import numpy as np
point1 = np.array([1, 0])
point2 = np.array([2, -1])
R = np.array([[-1, 0],[0, -1]])
# Rotate the endpoints of the line segment
rotated_point1 = np.dot(R, point1)
rotated_point2 = np.dot(R, point2)
print("Rotated endpoint 1: ", rotated_point1)
print("Rotated endpoint 2: ", rotated_point2)
Rotated endpoint 1: [-1 0]

Rotated endpoint 2: [-2 1]
[6]: # Using sympy, declare the points P(5,2),Q(5,−2),R(5,0), check whether these␣
↪points are collinear.
3
# Declare the ray passing through the points P and Q, find the length of this␣
↪ray between P and Q.
# Also find slope of this ray
P = Point(5, 2)
Q = Point(5, -2)
R = Point(5, 0)
line_PQ = Line(P, Q)
line_PR = Line(P, R)
collinear = line_PQ.is_parallel(line_PR)
# Print the result
if collinear:
print("Points P, Q, and R are collinear")
else:
print("Points P, Q, and R are not collinear")
# Calculate the length of the ray PQ
length_PQ = P.distance(Q)
# Calculate the slope of the ray PQ
slope_PQ = (Q.y - P.y) / (Q.x - P.x)
# Print the length and slope of the ray PQ
print("Length of the ray PQ:", length_PQ)
print("Slope of the ray PQ:", slope_PQ)
Points P, Q, and R are collinear

Length of the ray PQ: 4
Slope of the ray PQ: zoo

# Max Z = 150x + 75y
# subject to 4x + 6y �24
# 5x + 3y �15
# x �0,y �0
from pulp import *

Z= 150*x + 75*y
problem += Z
problem += 4*x + 6*y <=24
4
problem += 5*x + 3*y <=15
problem.solve()
Status: Optimal
Optimal x = 3.0
Optimal y = 0.0
Optimal Z = 450.0
[8]: # Write a python program to apply the following transformations on the point␣
↪(−2,4) :

import numpy as np
P=np.array([-2,4])

shearing_x = [P[0] + (4 * P[1]), P[1]]


Reflection through x-axis: [-2 -4]
5
Rotation about origin through an angle of 30 degree: [-3.73205081 2.46410162]

Python Slip Solution

Uploaded by

Copyright:

Available Formats

Python Slip Solution

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Python Slip Solution

Uploaded by

Copyright:

Available Formats

4/14/24, 10:41 PM slip1

# Item clothing Food rent Petrol Misc.

import matplotlib.pyplot as plt

In [4]: # Write a Python program to draw a polygon with vertices (0,0),(2,0),(2,3)

import matplotlib.pyplot as plt

theta = np.pi # 180 degrees

In [1]: # Write a Python program to solve the following LPP:

from pulp import *

print("Original point P:", P)

Original point P: [ 3 -1]

In [3]: # Using python, represent the following information using a bar gr

import matplotlib.pyplot as plt

from sympy import Point, Line

Points A, B, and C are not collinear.

In [4]: # Write a Python program to solve the following LPP:

from pulp import *

Original point P: [ 4 -2]

In [2]: # Following is the information of students participating in various games i

import matplotlib.pyplot as plt

In [6]: # f the line with points A[2,1],B[4,−1] is transformed by the transformatio

m_transformed = (y2_transformed - y1_transformed) / (x2_transformed - x1_tr

b_transformed = y1_transformed - m_transformed * x1_transformed

Equation of transformed line: y = -1.0 * x + 9.0

Midpoint: (5.0, 5.0)

In [3]: # Write a Python program to solve the following LPP:

from pulp import *

problem= LpProblem("Minimize Z", LpMinimize)

Original point P: [ 4 -2]

In [3]: # if the line with points A[3,1],B[5,−1] is transformed by the transformati

m_transformed = (y2_transformed - y1_transformed) / (x2_transformed - x1_tr

b_transformed = y1_transformed - m_transformed * x1_transformed

Equation of transformed line: y = 0.2 * x + 5.6

The equation of the line is: y = 0.00x + 3.00

In [4]: # Write a Python program to solve the following LPP:

from pulp import *

# Transformation 2: Rotation about origin through an angle of pi (180 degre

Transformed Point A after Shearing: [-5 -1]

def func(x, y):

import matplotlib.pyplot as plt

In [11]: # Write a Python program to solve the following LPP:

from pulp import *

print("Original point P:", P)

import matplotlib.pyplot as plt

In [13]: # Write a Python program to draw a polygon with vertices (0,0),(2,0),(2,3)

# Define the vertices of the polygon

# Plot the original polygon

# Rotate the polygon by 180 degrees

rotation_matrix = np.array([[np.cos(np.pi), -np.sin(np.pi)], [np.sin(np.p

# Plot the rotated polygon

In [14]: # Write a Python program to solve the following LPP:

from pulp import *

shearing_y = [P[0], P[1] + (3 * P[0])]

# Reflection through the line y = -x

print("Original point P:", P)

Original point P: [4, -2]

import matplotlib.pyplot as plt

from sympy import Point, Line

Points P, Q, and R are collinear

In [13]: # Write a Python program to solve the following LPP: