Applied Mathematics for Engineering

3. Linear Algebra

Linear algebra is a fundamental branch of mathematics that deals with vector spaces and linear mappings between them. It is an essential tool for engineers, as it helps in solving systems of linear equations, eigenvalue problems, and matrix operations. These concepts can be applied in various fields, such as robotics, control systems, and computer vision.

In this article, we will explore the applications of linear algebra in mechatronics and learn how to use Python and its NumPy library for engineering modeling and simulations.

3.1. Linear Systems of Equations

Linear systems of equations are sets of linear equations involving the same variables. These equations often arise in engineering when modeling relationships between multiple variables. For instance, when analyzing a mechanical structure, you might need to determine the forces acting on each component.

Let’s consider a system of linear equations as shown below:

\[\begin{cases} a_{11}x_1 + a_{12}x_2 + \dots + a_{1n}x_n = b_1 \\ a_{21}x_1 + a_{22}x_2 + \dots + a_{2n}x_n = b_2 \\ \dots \\ a_{m1}x_1 + a_{m2}x_2 + \dots + a_{mn}x_n = b_m \end{cases}\]

This system can be represented using matrices as:

\[\mathbf{A} \mathbf{x} = \mathbf{b}\]

Where:

\( \mathbf{A}\) is an \( m \times n\) matrix containing the coefficients of the variables
\( \mathbf{x}\) is an \( n \times 1\) column vector containing the variables
\( \mathbf{b}\) is an \( m \times 1\) column vector containing the constants

To find the values of \( \mathbf{x}\), we can use NumPy’s solve function:

import numpy as np

A = np.array([[a_11, a_12, ..., a_1n],
              [a_21, a_22, ..., a_2n],
              ...,
              [a_m1, a_m2, ..., a_mn]])

b = np.array([b_1, b_2, ..., b_m])

x = np.linalg.solve(A, b)

3.2. Eigenvalue Problems

Eigenvalue problems are essential in various engineering applications, such as determining the natural frequencies and mode shapes of a mechanical system or calculating the stability of control systems.

The eigenvalue problem can be formulated as:

\[\mathbf{A} \mathbf{v} = \lambda \mathbf{v}\]

Where:

\( \mathbf{A}\) is an \( n \times n\) square matrix
\( \mathbf{v}\) is a non-zero column vector (eigenvector)
\( \lambda\) is a scalar (eigenvalue)

To find the eigenvalues and eigenvectors of \( \mathbf{A}\), we can use NumPy’s eig function:

import numpy as np

A = np.array([[a_11, a_12, ..., a_1n],
              [a_21, a_22, ..., a_2n],
              ...,
              [a_n1, a_n2 , ..., a_nn]])

eigenvalues, eigenvectors = np.linalg.eig(A)

3.3. Robot Arm Kinematics

In robotics, linear algebra can be used to calculate the transformation matrices for robot arm kinematics. The transformation matrix represents the relationship between two coordinate frames, allowing us to transform points and vectors from one frame to another.

Given a robot arm with a series of joints and links, we can represent the position and orientation of each joint’s coordinate frame using Denavit-Hartenberg (DH) parameters. The DH parameters are four values, \( \theta, d, a, \alpha\), that describe the relative geometry between two consecutive joint frames.

For each joint, we can compute the transformation matrix using the DH parameters as:

\[\mathbf{T} = \begin{bmatrix} \cos{\theta} & -\sin{\theta}\cos{\alpha} & \sin{\theta}\sin{\alpha} & a\cos{\theta} \\ \sin{\theta} & \cos{\theta}\cos{\alpha} & -\cos{\theta}\sin{\alpha} & a\sin{\theta} \\ 0 & \sin{\alpha} & \cos{\alpha} & d \\ 0 & 0 & 0 & 1 \end{bmatrix}\]

To calculate the overall transformation matrix for the robot arm, we multiply the individual joint transformation matrices:

import numpy as np

def dh_transform(theta, d, a, alpha):
    T = np.array([[np.cos(theta), -np.sin(theta) * np.cos(alpha), np.sin(theta) * np.sin(alpha), a * np.cos(theta)],
                  [np.sin(theta), np.cos(theta) * np.cos(alpha), -np.cos(theta) * np.sin(alpha), a * np.sin(theta)],
                  [0, np.sin(alpha), np.cos(alpha), d],
                  [0, 0, 0, 1]])
    return T

T_total = np.eye(4)
for i in range(len(joints)):
    T_i = dh_transform(theta[i], d[i], a[i], alpha[i])
    T_total = np.dot(T_total, T_i)

This transformation matrix can be used to calculate the position and orientation of the robot’s end effector relative to the base coordinate frame.

3.4. Exercises

Example 1

Given a system of linear equations as follows, solve for \( \mathbf{x}\) using NumPy.

\[\begin{cases} 2x_1 + 4x_2 = 6 \\ 3x_1 - x_2 = 1 \end{cases}\]

Solution:

The solution for the given system of linear equations is:

import numpy as np

A = np.array([[2, 4],
              [3, -1]])

b = np.array([6, 1])

x = np.linalg.solve(A, b)
print(x)

Example 2

Find the eigenvalues and eigenvectors of the following matrix.

\[\mathbf{A} = \begin{bmatrix} 1 & 2 \\ 4 & 3 \end{bmatrix}\]

Solution:

The eigenvalues and eigenvectors can be found using the following code :

import numpy as np

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

eigenvalues, eigenvectors = np.linalg.eig(A)
print("Eigenvalues:", eigenvalues)
print("Eigenvectors:", eigenvectors)

Example 3

Calculate the transformation matrix for a single joint with the following DH parameters.

\[\theta = \frac{\pi}{2}, d = 1, a = 2, \alpha = \pi\]

Solution:

The transformation matrix for the given DH parameters can be calculated using:

import numpy as np

theta = np.pi / 2
d = 1
a = 2
alpha = np.pi

T = dh_transform(theta, d, a, alpha)
print(T)

Example 4

Write a Python program that takes a list of DH parameters and calculates the overall transformation matrix for a robot arm.

Solution:

A Python program that calculates the overall transformation matrix for a robot arm with a list of DH parameters:

import numpy as np

def dh_transform(theta, d, a, alpha):
    T = np.array([[np.cos(theta), -np.sin(theta) * np.cos(alpha), np.sin(theta) * np.sin(alpha), a * np.cos(theta)],
                  [np.sin(theta), np.cos(theta) * np.cos(alpha), -np.cos(theta) * np.sin(alpha), a * np.sin(theta)],
                  [0, np.sin(alpha), np.cos(alpha), d],
                  [0, 0, 0, 1]])
    return T

def robot_arm_transform(dh_parameters):
    T_total = np.eye(4)
    for params in dh_parameters:
        T_i = dh_transform(params[0], params[1], params[2], params[3])
        T_total = np.dot(T_total, T_i)
    return T_total

# Example DH parameters for a 3-joint robot arm
dh_params = [
    (np.pi/2, 1, 2, np.pi),
    (0, 2, 1, np.pi/2),
    (np.pi/4, 0, 3, 0)
]

T_total = robot_arm_transform(dh_params)
print(T_total)

This program defines a robot_arm_transform function that takes a list of DH parameters as input and returns the overall transformation matrix for the robot arm.

Applied Mathematics for Engineering

3. Linear Algebra

3.1. Linear Systems of Equations

3.2. Eigenvalue Problems

3.3. Robot Arm Kinematics

3.4. Exercises

Add Comment

Comments (1)