ರೇಖೀಯ ಬೀಜಗಣಿತದಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವು ಒಂದು ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.
ನಾವು ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್, ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ಮತ್ತು ಇನ್ನೂ ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ ಬಳಸುತ್ತೇವೆ. NumPy ವೈಜ್ಞಾನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್ಗಾಗಿ ಗಮನಾರ್ಹ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಆಗಿದೆ.
ಆದಾಗ್ಯೂ, ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, NumPy ಅನ್ನು ಬಳಸದೆಯೇ ಪೈಥಾನ್ನಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಮಾಡುವ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.
ನಾವು ಬಳಸಿಕೊಳ್ಳುತ್ತೇವೆ ನೆಸ್ಟೆಡ್ ಲೂಪ್ಗಳು, ಅಂತರ್ನಿರ್ಮಿತ ನಕ್ಷೆ() ಕಾರ್ಯ, ಮತ್ತು ಪಟ್ಟಿ ಕಾಂಪ್ರಹೆನ್ಷನ್.
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರತಿ ತಂತ್ರದ ಪ್ರಯೋಜನಗಳು ಮತ್ತು ಅನಾನುಕೂಲಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ, ಹಾಗೆಯೇ ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ಯಾವಾಗ ಅನ್ವಯಿಸಬೇಕು. ನೀವು ರೇಖೀಯ ಬೀಜಗಣಿತಕ್ಕೆ ಹೊಸಬರಾಗಿದ್ದರೆ ಮತ್ತು ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರದ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದರೆ; ಓದುವುದನ್ನು ಮುಂದುವರಿಸಿ.
ನಾವು ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಎಲ್ಲಿ ಬಳಸುತ್ತೇವೆ?
ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಕಂಪ್ಯೂಟರ್ ಗ್ರಾಫಿಕ್ಸ್ 2D ಮತ್ತು 3D ದೃಶ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲು. ಉದಾಹರಣೆಗೆ, ನೀವು ಪರದೆಯ ಮೇಲೆ ವಸ್ತುಗಳನ್ನು ತಿರುಗಿಸಬಹುದು, ಅಳೆಯಬಹುದು ಮತ್ತು ಅನುವಾದಿಸಬಹುದು. ಚಿತ್ರಗಳನ್ನು ಪಿಕ್ಸೆಲ್ಗಳ ಅರೇಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಲು ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್ನಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದಲ್ಲದೆ, ಇಮೇಜ್ ಫಿಲ್ಟರಿಂಗ್ನಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಡೆಸಲು ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳನ್ನು ಬಳಸಬಹುದು.
ನಾವು ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತೇವೆ ಯಂತ್ರ ಕಲಿಕೆ. ಡೇಟಾ ಮತ್ತು ಮಾದರಿ ನಿಯತಾಂಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅವರು ನಮಗೆ ಸಹಾಯ ಮಾಡಬಹುದು. ಕಂಪ್ಯೂಟಿಂಗ್ ಡಾಟ್ ಉತ್ಪನ್ನಗಳು ಮತ್ತು ಮ್ಯಾಟ್ರಿಕ್ಸ್-ವೆಕ್ಟರ್ ಉತ್ಪನ್ನಗಳಂತಹ ಹಲವಾರು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಾವು ನಡೆಸಬಹುದು.
ಖಂಡಿತವಾಗಿ, ಈ ಕಾರ್ಯಾಚರಣೆಯು ವೈಜ್ಞಾನಿಕ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ. ಭೌತಿಕ ಪ್ರಮಾಣಗಳನ್ನು ವಿವರಿಸಲು ನಾವು ಇದನ್ನು ಭೌತಶಾಸ್ತ್ರ ಮತ್ತು ಎಂಜಿನಿಯರಿಂಗ್ನಲ್ಲಿ ಬಳಸಬಹುದು. ಆದ್ದರಿಂದ, ನಾವು ವೆಕ್ಟರ್ಗಳು ಮತ್ತು ಟೆನ್ಸರ್ಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು.
NumPy ಅನ್ನು ಬಳಸಲು ನಾವು ಏಕೆ ಆಯ್ಕೆ ಮಾಡಬಾರದು?
NumPy ಆಗಿರುವಾಗ a ಪೈಥಾನ್ ಲೈಬ್ರರಿ, ಇದು ಯಾವಾಗಲೂ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರಕ್ಕೆ ಸೂಕ್ತ ಆಯ್ಕೆಯಾಗಿಲ್ಲ. ಗಾತ್ರ ಮತ್ತು ಅವಲಂಬನೆ, ಕಲಿಕೆ ಮತ್ತು ಪರಂಪರೆಯ ವ್ಯವಸ್ಥೆಗಳಂತಹ ಕಾರಣಗಳಿಗಾಗಿ ನಾವು NumPy ಅನ್ನು ಬಳಸಲು ಆಯ್ಕೆ ಮಾಡದಿರಬಹುದು.
ಪೈಥಾನ್ನ ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವುದು ಅಥವಾ ಕಸ್ಟಮ್ ಕೋಡ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು ಕೆಲವು ನಿದರ್ಶನಗಳಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು. ಆದಾಗ್ಯೂ, NumPy ಒಂದು ಬಲವಾದ ಗ್ರಂಥಾಲಯವಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಇದಲ್ಲದೆ, ನೀವು ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರಕ್ಕಾಗಿ ಇದನ್ನು ಬಳಸಬಹುದು.
ಈಗ, ನಾವು NumPy ಇಲ್ಲದೆ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಹೇಗೆ ಸಾಧಿಸಬಹುದು ಎಂಬುದನ್ನು ನೋಡೋಣ.
ನೆಸ್ಟೆಡ್ ಲೂಪ್ಸ್ ವಿಧಾನ
ನೆಸ್ಟೆಡ್ ಲೂಪ್ಸ್ ತಂತ್ರವು ಪೈಥಾನ್ನಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೆಸ್ಟೆಡ್ ಲೂಪ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಕಾರ್ಯವು ಪ್ರತಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅಂಶದ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ. ಮತ್ತು, ಇದು ನೆಸ್ಟೆಡ್ ಲೂಪ್ಗಳ ಸರಣಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳನ್ನು ಗುಣಿಸುತ್ತದೆ. ಕಾರ್ಯವು ಫಲಿತಾಂಶವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಅದನ್ನು ಹೊಸ ಮ್ಯಾಟ್ರಿಕ್ಸ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
ಈ ವಿಧಾನವು ಗ್ರಹಿಸಲು ನೇರವಾಗಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಇದು ಇತರ ವಿಧಾನಗಳಂತೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿರುವುದಿಲ್ಲ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳಿಗೆ. ಆದರೂ, ನೀವು ರೇಖೀಯ ಬೀಜಗಣಿತಕ್ಕೆ ಹೊಸಬರಾಗಿದ್ದರೆ ಇದು ನಿಮಗೆ ಅದ್ಭುತವಾದ ಆಯ್ಕೆಯಾಗಿದೆ.
def matrix_multiplication(A, B):
# Determine the matrices' dimensions.
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# ಫಲಿತಾಂಶದ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ಸೊನ್ನೆಗಳಿಗೆ ಹೊಂದಿಸಿ.
result = [[0 for row in range(cols_B)] for col in
range(rows_A)]
# Iterate through rows of A
for s in range(rows_A):
# Iterate through columns of B
for j in range(cols_B):
# Iterate through rows of B
for k in range(cols_A):
result[s][j] += A[s][k] * B[k][j]
return result
ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂಬುದರ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ಈ ಉದಾಹರಣೆಯನ್ನು ಪರೀಕ್ಷಿಸಲು ನೀವು ಈ ಕೆಳಗಿನ ಕೋಡ್ನ ಸಾಲುಗಳನ್ನು ಸೇರಿಸಬಹುದು.
# Sample matrices
A = [[1, 4, 3], [4, 9, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Perform matrix multiplication
result = matrix_multiplication(A, B)
# Print the result
print(result)
# Output: [[76, 84], [175, 194]]
ಪ್ರಯೋಜನಗಳು:
- ಗ್ರಹಿಸಲು ಸುಲಭ.
- ಹೊಸಬರಿಗೆ ಅಥವಾ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರದ ಆಳವಾದ ಗ್ರಹಿಕೆಯನ್ನು ಬಯಸುವವರಿಗೆ ಉತ್ತಮವಾಗಿದೆ.
ಅನಾನುಕೂಲಗಳು:
- ಪರ್ಯಾಯ ತಂತ್ರಗಳಂತೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿಲ್ಲ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಮ್ಯಾಟ್ರಿಕ್ಗಳಿಗೆ.
- ಇದು ಪರ್ಯಾಯ ವಿಧಾನಗಳಂತೆ ಓದಲಾಗುವುದಿಲ್ಲ.
ನಕ್ಷೆ () ಕಾರ್ಯ ವಿಧಾನ
ನಕ್ಷೆ() ಫಂಕ್ಷನ್ ವಿಧಾನವು ಪೈಥಾನ್ನಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರವನ್ನು ಮಾಡಲು ಪರ್ಯಾಯ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನದಲ್ಲಿ, ನಾವು ಅಂತರ್ನಿರ್ಮಿತ ನಕ್ಷೆ () ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ, ನಾವು ಪ್ರತಿ ಪುನರಾವರ್ತನೀಯ ಅಂಶಕ್ಕೆ (ಪಟ್ಟಿ, ಟುಪಲ್, ಇತ್ಯಾದಿ) ಒದಗಿಸಿದ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುವ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಉಪಕರಣವನ್ನು ಬಳಸುತ್ತೇವೆ. ಅಲ್ಲದೆ, ನಕ್ಷೆ() ಕಾರ್ಯವು ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಒಂದು ಕಾರ್ಯ ಮತ್ತು ಪುನರಾವರ್ತನೀಯ. ಮತ್ತು, ಇದು ಪ್ರತಿ ಪುನರಾವರ್ತನೀಯ ಅಂಶಕ್ಕೆ ಕಾರ್ಯವನ್ನು ಅನ್ವಯಿಸುವ ಪುನರಾವರ್ತಕವನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.
ಈ ವಿಧಾನದಲ್ಲಿ, ನಾವು ಮ್ಯಾಟ್ರಿಕ್ಸ್ನ ಪ್ರತಿ ಸದಸ್ಯರ ಮೂಲಕ ಹೋಗುತ್ತೇವೆ ಮತ್ತು ನೆಸ್ಟೆಡ್ ಮ್ಯಾಪ್() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಗುಣಾಕಾರವನ್ನು ಮಾಡುತ್ತೇವೆ.
ಜಿಪ್() ಕಾರ್ಯವನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಫಲಿತಾಂಶಗಳನ್ನು ಸೇರಿಸಲು ಮೊತ್ತ () ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
def matrix_multiplication(A, B):
# To get the dimensions of the matrices
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# We use map() function for multiplication.
result = [[sum(a * b for a, b in zip(row_a, col_b)) for
col_b in zip(*B)] for row_a in A]
return result
ಈಗ, ಮತ್ತೊಮ್ಮೆ, ನಾವು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಉದಾಹರಣೆಯೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಬಹುದು.
# Example matrices
A = [[3, 2, 3], [4, 5, 6]]
B = [[7, 8], [9, 10], [11, 12]]
# Use map() function to perform matrix multiplication
result = list(map(lambda x: list(map(lambda y: sum(i*j
for i,j in zip(x,y)), zip(*B))), A))
# Print the result
print(result)
# Output: [[72, 80], [139, 154]]
ಪ್ರಯೋಜನಗಳು
- ಜೋಡಿಸಲಾದ ಕುಣಿಕೆಗಳ ವಿಧಾನಕ್ಕಿಂತ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ
- ಕೋಡ್ ಅನ್ನು ಸರಳಗೊಳಿಸಲು ಇದು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
ಅನಾನುಕೂಲಗಳು
- ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ತಿಳಿದಿಲ್ಲದ ಕೆಲವು ಜನರು ಅದನ್ನು ಕಡಿಮೆ ಓದಬಲ್ಲರು.
- ನೆಸ್ಟೆಡ್ ಲೂಪ್ಸ್ ತಂತ್ರಕ್ಕಿಂತ ಇದು ಕಡಿಮೆ ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ.
ಪಟ್ಟಿ ಗ್ರಹಿಕೆ ವಿಧಾನ
ಪಟ್ಟಿಯ ಗ್ರಹಿಕೆಯು ಒಂದೇ ಸಾಲಿನ ಕೋಡ್ನಲ್ಲಿ ಹೊಸ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಆದ್ದರಿಂದ, ಇದು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪಟ್ಟಿಯ ಪ್ರತಿ ಸದಸ್ಯರಿಗೆ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಅನ್ವಯಿಸುವ ಮೂಲಕ.
ಈ ವಿಧಾನದಲ್ಲಿ, ಪ್ರತಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಸದಸ್ಯರ ಮೂಲಕ ಪುನರಾವರ್ತಿತವಾಗಿ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಮೂಲಕ ಗುಣಾಕಾರವನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ. ನಾವು ಲೇಯರ್ಡ್ ಲಿಸ್ಟ್ ಕಾಂಪ್ರಹೆನ್ಷನ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ.
# Sample matrices
A = [[1, 12, 3], [14, 5, 6]]
B = [[7, 8], [9, 10], [12, 12]]
# Matrix multiplication using list comprehension
result = [[sum(A[i][k] * B[k][j] for k in range(len(A[0])))
for j in range(len(B[0]))] for i in range(len(A))]
# Print the result
print(result)
[[151, 164], [215, 234]]
ಪ್ರಯೋಜನಗಳು
- ನಕ್ಷೆ() ಕಾರ್ಯ ವಿಧಾನಕ್ಕೆ ಹೋಲಿಸಿದರೆ, ಚಿಕ್ಕದಾಗಿದೆ ಮತ್ತು ಹೆಚ್ಚು ಓದಬಹುದಾಗಿದೆ.
ಅನಾನುಕೂಲಗಳು
- ಇದು ನಕ್ಷೆ() ಕಾರ್ಯವನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಕಡಿಮೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿರಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳಿಗೆ.
- ನೆಸ್ಟೆಡ್ ಲೂಪ್ಸ್ ವಿಧಾನಕ್ಕಿಂತ ಇದು ಹೆಚ್ಚು ಕಷ್ಟಕರವಾಗಿದೆ.
ತೀರ್ಮಾನ
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ಪೈಥಾನ್ನಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳನ್ನು ಗುಣಿಸುವಾಗ NumPy ಅನ್ನು ಬಳಸುವ ಪರ್ಯಾಯಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ. ನಾವು ನೆಸ್ಟೆಡ್ ಲೂಪ್ಗಳಲ್ಲಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರ, ಅಂತರ್ನಿರ್ಮಿತ ನಕ್ಷೆ() ಕಾರ್ಯ ಮತ್ತು ಪಟ್ಟಿಯ ಗ್ರಹಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಿದ್ದೇವೆ.
ಉತ್ತಮ ತಂತ್ರವು ನಿಮ್ಮ ಯೋಜನೆಯ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ಪ್ರತಿಯೊಂದು ತಂತ್ರವು ತನ್ನದೇ ಆದ ಸಾಧಕ-ಬಾಧಕಗಳನ್ನು ಹೊಂದಿದೆ. ಕಾರ್ಯವು ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ವಿವಿಧ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಆಯಾಮಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕೆಲವು ಪರೀಕ್ಷಾ ಪ್ರಕರಣಗಳನ್ನು ಸೇರಿಸುವುದು ಒಳ್ಳೆಯದು.
ಈ ವಿಧಾನಗಳು ಎಷ್ಟು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಹೋಲಿಸಲು ನೀವು ಕೆಲವು ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಸಹ ಸೇರಿಸಬೇಕು.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ