A Review and Comparative Study of Differential Evolution Algorithms in Solving Inverse Kinematics of Mobile Manipulator

Abstract

Mobile manipulator robots have become important pieces of equipment due to the high mobility of mobile subsystems and the high flexibility of manipulator subsystems. Considering the increasing degrees of freedom and the need to avoid singular locations, one of the most challenging problems is solving the inverse kinematics problem of mobile manipulator robots (IKMM). Of all the popular optimization algorithms, the differential evolution (DE) algorithm is the most effective method for quickly solving the IKMM problem with sufficient solutions. Currently, many strategies have been proposed for DE algorithms to improve the performance of solving mathematical problems; some symmetry strategies or symmetry functions have been introduced to DE algorithms. However, the effects of various DE algorithms on solving the actual IKMM lack a comprehensive explanation. Therefore, we divide various DE algorithms into three categories considering the control parameter selection and compare the specific optimization of various DE algorithms. Then, we compare the performance of various DE algorithms when solving the inverse kinematics problems of mobile manipulators with different degrees of freedom. Considering the effectiveness and the speed of the DE algorithm on the IKMM problem, we determine the best DE algorithm by comparing the error and time required to reach 100 random mission points and tracking the typical trajectories. Finally, the best-performing DE method is further improved by studying the selection of fundamental parameters in the best DE algorithm. Valuable conclusions are obtained from these experimental simulations, which can help with choosing an algorithm that is suitable for solving the inverse kinematics problem of mobile manipulator robots in practice.

1. Introduction

A mobile manipulator fixes a manipulator on a mobile platform to improve the performance of traditional fixed manipulator robots [1]. Mobile platform subsystems can increase the robot workspace and increase the flexibility of system operation [2]. Based on these advantages, mobile manipulator robots currently have become a topic of research and application in many fields, including outer space detection [3], object handling [4], environment detection [5], and personnel assistance [6,7]. In these studies of manipulator robots, forward kinematics have mainly been used to solve the position and posture of the robot end-effector [8]. The aim of inverse kinematics (IK) is primarily to find the angle of each driving joint for ensuring that the end effector can reach a point with a given position and posture [9]. Compared with the single result of forward kinematics, a mobile manipulator’s inverse kinematics are more complicated due to the nonlinear mapping of joint angles and end points [10]. At present, a mobile manipulator robot’s IK problem is more challenging than that of other fixed manipulator robots considering the limitations in practical applications, such as the increased complexity [11], stringent precision requirements [12], joint angles [13], and optimization of motion time [14].

To solve these challenging problem, researchers have proposed many methods, including the analytical method [15], Jacobian-based method [16], neural network method [17,18,19], numerical method [20,21], and swarm intelligence algorithm [22,23]. The analytical method [24] directly uses math formulas to describe the relationship between the end point and the driving joints based on the basic structure of the robot. Due to the increased complexity regarding degrees of freedom and structure, the geometric analysis method may be inappropriate for robots with high DOFs (Degree of freedoms). As one of the most traditional methods, the Jacobian-based method [25,26] is based on the continuous iteration of the Jacobian matrix in the speed layer to solve the IK problem. However, this method cannot effectively solve a singular value or reduce the solution time. By constructing multilayer neural learning, the neural network method [27,28,29] directly solves the nonlinear relationship between the joint angles and the end point. This method has higher complexity in programming and needs a longer time for high-degree-of-freedom robots. The numerical method [30] transforms the IK problem into quadratic programming by considering various constraints. Then, we finally obtain the final inverse kinematics result through various numerical solution methods [31]. In numerical methods, the inverse kinematics solution mainly focuses on the velocity and acceleration layers [32]. The position layer inverse kinematics cannot be solved, and accurate solution results cannot be obtained for various constraints and singular points. The swarm intelligence algorithm is still the most productive solution based on the characteristics of biological swarms. Various swarm intelligence methods [33,34] have been proposed, such as PSO (Particle Swarm Optimization), GA (Genetic Algorithm), AA (Ant Algorithm), and DE (Differential Evolution). The swarm intelligence algorithms have become the most effective method to solve the IK problem.

In all types of typical intelligent algorithms, the DE algorithm is the most effective and extensive, being widely used in solving TSP, path planning, trajectory tracking, etc. When solving the TSP problem, the path between nodes i and j is usually symmetrical, that is, the distance from node i to j is equal. Based on this characteristic, the DE algorithm can find the shortest distance that traverses all nodes with its explore and explosive ability. A multiobjective algorithm that hybridizes the DE algorithm with a PSO is proposed [35]. The path length, degree of safety, and degree of smoothness are taken as the the objectives to optimize. The experiment results reveal that the hybrid algorithm outperforms the other algorithms on three metrics. Researchers [36] proposed an $ϵ$-constrained adaptive DE algorithm to solve optimal power flow problems. The $ϵ$-constrained strategy is improved to tackle the constraints, and a p-best selection method based on the constraint violation is implemented in the adaptive differential evolution. Authors [37] propose a modified differential evolution algorithm (ENMDE, Efficient and New Modified Differential Evolution) to solve two short-term hydrothermal scheduling problems. In the improved algorithm, a self-tuned mutation strategy and a leading group selection strategy are used to select the local search method or the global search method based on the evaluation of the solution. The improved DE algorithm perform better than the conventional DE not only in providing the optimal solutions but also in reducing the computation. Authors [38] propose a new differential evolution variant (PDcDE, Population Diversity-controlled Differential Evolution) to estimate the parameters of solar PV models. In the improved algorithm, three strategies are introduced, the swarm size is adjusted by an auto-controlled population strategy, the scale factor is set by a diversity-controlled method, and a backward search is used to avoid the local optima. The results show that the performance of PDcDE is superior in efficiency and effectiveness for parameter estimation. The DE algorithm is also widely used for solving the IK problem. For example, the DE algorithm is applied to solve the IK problem of a fixed manipulator, showing that the performance of the DE algorithm with the rand1 method is better than the PSO algorithm through many experiments [39]. The author [40] propose an ISAMDE (Improved Self-Adaptive Mutation Differential Evolution.) algorithm and apply the DE algorithm to a mobile manipulator robot and compare the performance when tracking different trajectories, which show that the DE algorithm has many advantages in solving the IK of mobile manipulatosr. Compared with the traditional method, the DE algorithm [41] is applied to the collaborative task of multimobile manipulator robots. The method could effectively solve the problem by redefining the constraint conditions. Researchers [42] plan a minimum-acceleration trajectory for a humanoid robot. The results indicate that the improved DE algorithm is effective for this task with a seven-DOF manipulator. The DE algorithm [43] provides the fastest solution speed and the best solution, avoids singular points, and ensures smooth motion.

In the literature, researchers have continued to optimize the DE algorithm and have proposed various methods including FADE (Fuzzy Adaptive Differential Evolution) [44], SADE (Self-adaptive Differential Evolution) [45,46,47], JDE [48], JADE [49,50], CODE (composite Differential Evoluton) [51], SAMDE (Self-adaptive Mutation Differential Evoluton) [52], and ODE (Opposition-based Differential Evolution) [53,54,55]. These improvements have mainly focused on crossover operations, mutation operations, mutation factors, and crossover probability. Many symmetry strategies have been used in the improved algorithms; for example, the ODE algorithm uses the symmetry idea to generate a new opposite solution and ensure the diversity of the group. Additionally, common symmetric distribution functions such as the Cauchy distribution and Gaussian normal distribution have been introduced into NSDE (Neighbour Search Differential Evolution) and JADE. Various aspects have been reviewed and improved by researchers for solving mathematical problems. However, the DE algorithm lacks more in-depth analysis and research in solving the IK problem of mobile manipulators. For example, different DE algorithms perform differently when solving the IK problem. We need to determine how to optimize the performance of the DE algorithm for solving the inverse kinematics problem, which is the most appropriate DE algorithm for solving the inverse kinematics problem of mobile manipulators with different degrees of freedom, and how to set the control parameters in the most appropriate DE algorithm.

In this study, we mainly focused on the practical applications of the DE algorithm in solving the IK problem of mobile manipulators with various DOFs. The specific contributions can be summarized as follows:

(1)

We provide a detailed description of the improvement directions of typical differential evolution algorithms. To facilitate in-depth understanding and research, we effectively divide the various differential algorithms into three categories according to the selection of different control parameters.

(2)

We redefine the IK problem of mobile manipulators as a global optimization problem and propose a variety of different fitness functions to meet the constraints existing for the solution of robot IK problems. The specific steps of the differential evolution algorithm to solve the inverse kinematics problems are described.

(3)

We determine the most appropriate DE algorithm to obtain the solution for a mobile manipulator and to further improve the performance of the differential evolution algorithm through the selection and optimization of control parameters.

(4)

The influence of DOFs on the performance of different DE algorithms are also analysed. With the increasement of robot DOFs, the inverse kinematics problems become more complex, the difference in effectiveness and applicability of each algorithm become obvious. The comparison simulation experiments can help scholars optimize their improved DE algorithm and select proper parameter value and strategies effectively.

(5)

Specific optimization content of different DE algorithms is compared. The combination direction to hybridize the DE algorithm with other algorithms is also provided.

The rest of this paper is organized as follows: In Section 2, we establish a model of a mobile manipulator, and we specifically describe the problems of forward and inverse kinematics. In Section 3, we classify various differential evolution methods based on the key parameter selection methods and describe the improvement directions. In Section 4, we redefine the inverse kinematics of the mobile manipulator as a numerical optimization problem, and we describe the specific steps of the DE algorithm to solve the optimization problem. Section 5 describes multiple experiments that are designed to analyze the effects of various differential evolution methods on the inverse kinematics of different mobile manipulators and to determine the specific effects of parameters on the optimal differential evolution. The final section summarizes the paper.

2. Preliminary Knowledge

In this section, we introduce the basic structure and key technologies of mobile manipulator in forward kinematics and inverse kinematics.

2.1. Physical Model

To reduce the difficulty of the calculation, researchers have treated the mobile manipulator as an open-loop chain structure by referring to manipulator modeling technology. As such, the forward kinematics of a mobile manipulator (FKMM) can be established by analyzing the motion relationship between the driving joints and connecting links. Although the structure and DOFs of a mobile manipulator may widely differ the basic kinematics modeling method is the same. Figure 1 depicts a typical simplified structure of a mobile manipulator robot.

2.2. Kinematics Model

The transformation matrix method is widely used for solving the forward kinematics of mobile manipulators. Therefore, except for the corresponding joint angles, the end position of the mobile manipulator is affected by the fixed position of the manipulator subsystem and the current state of the mobile platform subsystem. The assumption is that the mobile manipulator robot moves on the horizontal plane $\left(XOY\right)$. Then, the end position of the manipulator is controlled by the corresponding joint angle. Therefore, the control variable of the robot is expressed as follows:

$$q={[q_m,q_a]}^T={[d_x,d_y,q_z,q_1,q_2,q_3,\dots \dots ,q_n]}^T$$

(1)

where $q_m$ represents the control variable of the mobile platform subsystem, $q_a$ represents the control variable of the manipulator subsystem, $d_x$ represents the movement distance along the X axis of the mobile platform, $d_y$ represents the movement distance along the Y axis of the mobile platform, $q_z$ represents the rotation angle around the Z axis of the mobile platform, and $q_i$ represents the drive joint of the robotic arm.

To reduce the difficulty of kinematic modeling, we directly establish a standard coordinate frame on the mobile platform instead of the three coordinate frames established by other researchers. Additionally, the joint-fixed coordinate frame is directly established based on the typical SDH (standard Denavit-Hartenberg) method. Considering the fixed connection between the two subsystems, the position and posture of the mobile manipulator’s end effector can be directly expressed as follows:

$$T_e={}^o{T}_c{}^c{T}_b{}^b{T}_e$$

(2)

where ${}^o{T}_c$, ${}^b{T}_e$, and ${}^c{T}_b$ represent the homogeneous transformation matrix of the mobile, tool-fixed, and based-fixed coordinate frames, respectively.

In the actual solution process, the generally specified task only contains the position of the target point in Cartesian space (not including the pose). Therefore, we need to extract the corresponding position from the homogeneous transformation matrix, which can be expressed as:

$$p=f\left(q\right)$$

(3)

where, p represents the position of the end effector, q indicates the corresponding driving joints, and $f\left(\right)$ represents the extracted function from the forward kinematics matrix of the mobile manipulator. And the IK problem of the mobile robot can be directly expressed as:

$$q=f^{-1}\left(p\right)$$

(4)

where $f^{-1}\left(\right)$ represents the IK function of the mobile manipulator, q represents the final joint angle, and p represents the position information (or including posture information) of the end effector.

Most mobile manipulators have redundant degrees of freedom and variable structural features. Therefore, theoretical analysis methods cannot effectively be applied on the robot. The conventional solution method is the pseudo-inverse method in the speed layer. However, the method has many shortcomings such as not avoiding the singular position, higher complexity in solving the matrix inverse, and large error in the final result. Therefore, researchers have used various popular optimization algorithms to solve the IK problem. Among these methods, the DE algorithm performs well so has become the most effective solution method.

Remark 1.

Positioning of the mobile platform. To ensure precision and stability, the mobile platform is mainly composed of rigid components, and the connecting parts are rigidly connected. The movement process does not occur skidding or sliding. The angular velocity of the driving wheels of the mobile platform is directly controlled by motors. The formulation of the mobile-fixed coordinate frame is expressed as follows:

$${}^o{T}_c=\left[\begin{array}{cccc}cos\left(q_{zc}\right)& -sin\left(q_{zc}\right)& 0& p_{xc}\\ sin\left(q_{zc}\right)& cos\left(q_{zc}\right)& 0& p_{yc}\\ 0& 0& 1& p_{zc}\\ 0& 0& 0& 1\end{array}\right]$$

(5)

where $p_{xc},p_{yc},p_{zc}$ represents the center position information of the drive wheels, and $q_{zc}$ represents the posture information.

Remark 2.

Positioning of end effector. Because the joint-fixed coordinate frame is established on each joint based on the traditional modeling method, the homogeneous transformation matrix can directly describe the position and posture of adjacent coordinate frames. Therefore, the position and posture of the end effector can be expressed as follows:

$${}^b{T}_e={}^b{T}_1·{}^1{T}_2·\dots \dots ·{}^{n-1}{T}_n·{}^n{T}_e$$

(6)

where ${}^{n-1}{T}_n$ represents the homogeneous transformation from the joint(n−1)-fixed coordinate frame to the joint(n)-fixed coordinate frame. The formulation can be expressed as:

$$\begin{array}{c}{}^{i-1}{T}_i=Rot\left(q_i\right)·Tran\left(d_i\right)·Rot\left({\alpha }_i\right)·Tran\left(a_i\right)\hfill \end{array}$$

(7)

where ${\alpha }_i$ represents the twist angle of the links, $a_i$ represents the link length, $q_i$ is the rotation joint angle, $d_i$ represents the link offset.

Remark 3.

Positioning of the connection components. The position of the connection part is determined in the actual application of the robot. Therefore, we can determine the relationship between the based-fixed coordinate frame and the mobile-fixed coordinate frame:

$${}^c{T}_b=Tl\left(\right[\begin{array}{ccc}d{x}_{cb}& d{y}_{cb}& d{z}_{cb}\end{array}\left]\right)R_x\left(q{x}_{cb}\right)R_y\left(q{y}_{cb}\right)R_z\left(q{z}_{cb}\right)$$

(8)

where $d{x}_{cb}$, $d{y}_{cb}$, and $d{z}_{cb}$ represent the three distances that the based-fixed coordinate frame moves along the three axes of the mobile-fixed coordinate frame; $q{x}_{cb}$, $q{y}_{cb}$, and $q{z}_{cb}$ represent the three rotation angles of the based-fixed coordinate frame around the three axes of the mobile-fixed coordinate frame; $Tl\left(\right)$ represents the homogeneous transformation matrix; and $R_x\left(q{x}_{cb}\right),R_y\left(q{y}_{cb}\right),R_z\left(q{z}_{cb}\right)$ represents the homogeneous transformation matrix of the rotation motion along the $X,Y,Z$ axes, respectively.

Remark 4.

Target point task. Due to the mobile manipulator being far from the target point in the early stage of the actual task, the inverse kinematics solution only ensures that the all positions can be accurately reached by the end effector. When reaching the position near the target point, the robot needs to accurately perform the task, and the state of the target task needs to be considered.

3. Typical DE Algorithms

In this section, we describe the specific steps of the DE algorithm. To facilitate further research on DE algorithms, we classified the various DE algorithms based on the coefficient of the mutation operation. Additionally, we compared and summarized the exact differences and characteristics of various DE algorithms.

3.1. Basic DE Algorithm

The DE algorithm is one of the simplest methods of the swarm intelligence algorithm. The solution of the optimization problem based on the DE algorithm is obtained through a cooperation and competition strategy between different populations in a group. The implementation of the differential evolution algorithm requires the following four steps: initialization, mutation, crossover, and selection.

(1)

Initialization. Various sets with NP elements are randomly constructed to solve the optimization problem. To ensure that each element in the created sets meets the lower and upper boundaries, we use the Monte Carlo method to initialize the individuals. Each individual can be expressed as follows:

$$x_{i,go}^j=x_{min}^j+rand(0,1)(x_{max}^j-x_{min}^j),j=1,2,\dots ,NP$$

(9)

where $x_{i,go}^j$ represents the $jth$ element in the $ith$ set in the group; $x_{min}^j$ and $x_{max}^j$ represent the lower and upper boundary, respectively; and $rand\left(\right)$ represents a random number in $[0,1]$.

(2)

Mutation. New individuals are constructed by multiple different individuals in the parent group. A mutation strategy is used to distinguish it from other intelligence algorithms. This step can be explicitly expressed as:

$$V_{i,g}=X_{r1,g}+F·(X_{r2,g}-X_{r3,g})$$

(10)

where $V_{i,g}$ represents the new individuals different from the parent group; $X_{r1,g}$, $X_{r2,g}$, and $X_{r3,g}$ represent three different sets in the parent group; F represents the scaling factor; and $(X_{r2,g}-X_{r3,g})$ represents the difference vector used for mutation.

(3)

Crossover. A new group is established through crossover operations between parent and mutant individuals. To ensure the group’s evolution, we combine parental and variant individuals to create a new group during the crossover process. The crossover probability of mutation is determined, which can be expressed as:

$$u_{i,g}^j=\{\begin{array}{c}\begin{array}{cc}{v}_{i,g}^j,& if(rand\left(\right)<CR)or(j=j_{rand})\end{array}\\ \begin{array}{cc}{x}_{i,g}^j,& else\end{array}\end{array}$$

(11)

where $u_{i,g}^j$ represents the new individual established by the crossover process, $v_{i,g}^j$ represents the new individual generated by the mutation, $x_{i,g}^j$ represents the original individual in the parent group, and $CR$ represents the cross-ratio coefficient.

(4)

Selection. The best set is selected by comparing the fitness function in a different set of the new group. In this step, the current optimal set is selected from these above-mentioned overall cross-mutated group, which can be expressed as:

$$x_{i,g+1}^j=\{\begin{array}{c}\begin{array}{cc}{u}_{i,g}^j,\hfill & if(fit\left(u_{i,g}^j\right)<fit\left(x_{i,g}^j\right))\end{array}\\ \begin{array}{cc}{x}_{i,g}^j\hfill & else\end{array}\end{array}$$

(12)

where $x_{i,g+1}^j$ represents the best individual of the current group, and $fit\left(\right)$ represents the fitness function of the objective problem.

3.2. Optimized DE Algorithm

As a mutation algorithm of the genetic algorithm, the DE algorithm has become popular in research due to having fewer control parameters and higher solving efficiency. According to the critical operation steps, the optimization of the DE algorithm has mainly focused on the crossover and mutation processes. According to the different settings of the control parameters, we divided various DE algorithms into three categories and studied the specific optimization trend of DE algorithms.

3.2.1. Deterministic Parameter Control

Deterministic parameter control means that the scaling factor F and the crossover probability CR take fixed values and do not change over time. This type of DE algorithm is relatively simple, and the most typical optimization methods include the typical DE algorithm (TDE), the opposition-based learning DE algorithm (ODE), the composite DE algorithm (CODE), and the adaptive mutation DE algorithm (AMDE).

(A1) TDE

The aim of the typical DE is to obtain a more optimized group through the correction of individual information in the group. As an essential step of the DE algorithm, the scaling factor and the difference vector of the mutation can substantially impact the solution speed and accuracy of the population. The mutation process also has a key control variable that affects the diversity of the population. Therefore, many researchers choose mutation operation as the primary trend for improving the DE algorithm. According to the initial population, the mutant individual can choose the best individual or a random individual in the current group as the primary solution. The difference vector can be solved by randomly selecting different sets in the group or selecting the best set and some random sets. Through the selection of two different parameters, researchers have developed various DE algorithms. DE represents the differential evolution principle of the system; best or rand represents the random selection and the latest selection method; and 1 or 2 represents the number of the different vector used in the system. The current mainstream mutation operations of the DE algorithm are as follows:

$$\begin{array}{c}\left(1\right)DE/rand/1:\hfill \\ \begin{array}{cc}& \end{array} \hspace{0.17em}{V}_i(t+1)=X_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \\ \left(2\right)DE/best/1:\hfill \\ \begin{array}{cc}& \end{array} \hspace{0.17em}{V}_i(t+1)=X_{best}\left(t\right)+F(X_{r1}\left(t\right)-X_{r2}\left(t\right))\hfill \\ \left(3\right)DE/rand/2:\hfill \\ \begin{array}{cc}& \end{array} \hspace{0.17em}{V}_i(t+1)=X_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right)+\lambda (X_{r4}\left(t\right)-X_{r5}\left(t\right))\hfill \\ \left(4\right)DE/best/2:\hfill \\ \begin{array}{cc}& \end{array} \hspace{0.17em}{V}_i(t+1)=X_{best}\left(t\right)+F(X_{r1}\left(t\right)-X_{r2}\left(t\right))+\lambda (X_{r3}\left(t\right)-X_{r4}\left(t\right))\hfill \\ \left(5\right)DE/current-best/1:\hfill \\ \begin{array}{cc}& \end{array} \hspace{0.17em}{V}_i(t+1)=X_i\left(t\right)+F(X_{best}\left(t\right)-X_i\left(t\right))+\lambda (X_{r1}\left(t\right)-X_{r2}\left(t\right))\hfill \end{array}$$

(13)

where $r1$, $r2$, and $r3$ represent the three random indices of the fitness functions in the current group, respectively; and $best$ represents the index of best fitness function in current group.

The result of the mutation cannot guarantee that the new set is within the constraints of the optimization problem. Therefore, researchers again restrict the individuals to ensure that the crossover results are within the specified constraints. The specific solution results are:

$$\{\begin{array}{c}{u}_i=v_i,if(u_L<v_i<u_U)\\ u_i=u_L+rand·(u_U-u_L),otherwise\end{array}$$

(14)

where $u_i$ represents the mutated individual, $[u_L,u_U]$ represents the constraint range of the group in the solution process, and $v_i$ represents the latest mutated individual.

(A2) ODE

The ODE algorithm [53] mainly optimizes the DE algorithm by selecting the initial population. The basic principle of the initial population is based on opposition-based learning. This method mainly adds the inverse function of random data, and a new symmetry solution is generated based on the initial solution, ensuring that the initial population is more evenly distributed. The inverse function of a random number in a given range can be expressed as:

$$X^{*}\left(i\right)=X_l\left(i\right)+X_u\left(i\right)-X\left(i\right)$$

(15)

where $X^{*}$ indicates the inverse function; $X_u$ and $X_l$ indicate the maximum and minimum values in the given range, respectively; and X indicates the random number.

After solving the corresponding fitness and effective sorting, a more suitable individual is selected to meet the required population size from the initial population in the ODE algorithm. Assuming PB is denoted as the randomly selected population, PO is denoted as the inverse function of the corresponding population, and the overall population can be expressed as P = PB + PO. After the crossover operation, the population is optimized again according to the random number and the inverse function learning probability. According to the mutation operation, a “neighbor-neighbor” strategy is redefined, which is explicitly expressed as:

$$V_{r3}(t+1)=X_i\left(t\right)+F(X_{best}\left(t\right)-X_{r3}\left(t\right))+\lambda (X_{r1}\left(t\right)-X_{r2}\left(t\right))$$

(16)

where i and $r3$ are selected from the best-ranked populations, which are mainly used for the optimal detection of adjacent space; and $r1$ and $r2$ are randomly selected from the original population, which are used to improve the detection capability of the global scope.

(A3) CODE

The composite DE algorithm is developed by improving the mutation operation and control parameters. In most situations, different mutation operations have different effects on the results. So, multiple mutation operations and control coefficients are selected for the DE algorithm based on the above considerations.

The CODE algorithm randomly selects three mutations from various mutation strategies as the next generation. After each population is initialized, three different new populations are generated based on the three mutation strategies. The specific mutation operations and the coefficients can be expressed as:

$$\begin{array}{c}\left(1\right)DE/rand/1:[F=1.0,C_r=0.1]\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \\ \left(2\right)DE/rand/2:[F=1.0,C_r=0.9]\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right)+\lambda (X_{r4}\left(t\right)-X_{r5}\left(t\right))\hfill \\ \left(3\right)DE/current-to-rand/1:[F=1.0,C_r=0.2]\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_i\left(t\right)+F(X_{r1}\left(t\right)-X_i\left(t\right))+\lambda (X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \end{array}$$

(17)

where $r1,r2,r3$, and $r4$ are randomly selected from the group; i indicates the original population; and $V_i$ represents the result of the mutation operation.

The CODE algorithm has many mutation strategies, but the control parameter is still a fixed value. Therefore, the CODE algorithm can be regarded as an optimization algorithm with a fixed coefficient of determination.

(A4) AMDE

The AMDE algorithm also selects different mutation operations to increase the group’s diversity. Researchers combined rand and best mutation to maintain the local convergence performance and global exploration ability. When the new set is superior to the current individual, the parent individual is directly replaced to produce the next individual. The AMDE algorithm chooses the traditional rand/1 and best/2 as the basic mutation operations. rand/1 can maintain the global exploration ability of the system, and best/2 is used to maintain the convergence performance. To effectively select two parameters in the mutation process, any specific selection is based on comparing the total time of the population iteration process and the random number. The corresponding differential evolution method can be described as:

$$V_i(t+1)=\{\begin{array}{c}{X}_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right));if(rand<1-{(t/T)}^2)\\ X_{best}\left(t\right)+F(X_{r1}\left(t\right)-X_{r2}\left(t\right));otherwise\end{array}$$

(18)

where $r1,r2$, and $r3$ are randomly selected from the original population; T represent the maximum iteration number of the problem.

Constraints are applied to the new individuals in the traditional algorithm to ensure that the population individuals are within a given range space to ensure that the system’s mutant individuals are within a given motion solution range; specifically, this can be expressed as:

$$W_i(t+1)=\{\begin{array}{c}{X}_l-rand·(X_l-X_u);otherwise\\ V_i(t+1);if(X_l<V_i<X_u)\end{array}$$

(19)

where $X_l$ represents the maximum value and the latest value of the given population for the individual, $rand$ represents the random value in the range $[0,1]$, $V_i$ represents the current iteration individual, and $W_i$ represents the new individual selected.

Generally speaking the performance of an algorithm is influenced by its explore ability and exploit ability, the random (rand) strategy can enhance the explore ability, help the group keep diversity, and prevent the group from falling into local optimum, the best strategy can improve the exploit ability of the algorithm and emphasize the rate of convergence. Compared with the DE/best/1, DE/best/2 and DE/current-best/1 algorithms, the fitness values of the DE/rand/1, DE/rand/2, ODE, and CODE algorithms converge to a small range. Due to the random strategy and the opposite strategy in the algorithms. The group shows better diversity, so their results are relatively stable. However, the precision of the algorithms may sometimes be low for the lack of local search. The performance of DE/best/1 and DE/best/2 are strongly affected by the scale factor F. Although the fitness values of the DE/best/1, DE/best/2, DE/current-best/1 and CODE algorithms converge to a large range, some of their results are highly precise for the best strategy; they can solve high-precision problems that other algorithms cannot with better exploit ability. Due to many strategies are used in the CODE algorithm, the calculation time is always long.

3.2.2. Adaptive Parameter Control

In adaptive parameter control methods, the coefficient of variation F and the crossover probability CR are randomly selected. However, the choice of the two key parameters may or may not be affected by the previous results. The most typically used adjustment coefficient optimization method is the DE algorithm with neighborhood search (NSDE).

(B1) NSDE

The basis of the NSDE algorithm is that different mutations perform differently in the solving areas near the optimal local value. A smaller mutation factor can ensure convergence near the optimal local value, but it cannot obtain the global optimal solution. A larger mutation factor can improve the searchability of the nearby global optimal solution, but more time is required to achieve local convergence. Therefore, researchers proposed a random variable factor to optimize the problem.

In the NSDE algorithm, $d=x_{r1}-x_{r2}$ is the step size in the adjacent space exploration. When near the optimal value, the value is automatically reduced. When the crosser coefficient F adopts a changing value, more jump steps can be generated. Compared with the fixed mutation parameters, this method can generate a more diverse group. At the same time, a variable mutation factor can ensure that the solution result escapes from the local range to reach the optimal global range. Because Gaussian random distribution provides better mean concentration performance and the Cauchy random distribution has better global distribution performance, researchers have effectively used the above methods to improve the DE algorithm. The specific variation factor can be expressed as:

$$F=\{\begin{array}{c}\begin{array}{cc}{N}_i(0.5,0.5);& if(U(0,1)<f_p)\end{array}\\ \begin{array}{cc}\delta ;& otherwise\end{array}\end{array}$$

(20)

where $N_i(0.5,0.5)$ represents a random number in the Gaussian distribution with a corresponding mean of 0.5 and a standard deviation of 0.5; $\delta$ represents a random number in the Cauchy random distribution with the corresponding key parameter $t=1$.

The NSDE algorithm improves the neighborhood search mechanism and make better use of local information in search space. So it shows a high optimization success rate and the precision is relatively high; however, the neighborhood search mechanism may increase the computational complexity of the algorithm. the calculation of the algorithm is large and the time-consuming. The performance of the algorithm is highly dependent on the characteristics of the problem and may not be the optimal choice for some problems.

3.2.3. Self-Adaptive Parameter Control

We obtain the critical parameters by applying the concept of “evolution in evolution” in self-adaptive parameter control optimization methods. Therefore, some researchers have added self-adjustment functions to the coefficient of variation F and crossover probability CR of the DE algorithm. The most typical adaptive adjustment coefficient optimization methods include JDE, JADE, and SADE.

(C1) JDE

The mutation and crosser operations strongly affect the DE algorithm when solving optimization problems. The values of the different coefficients affect a DE algorithm having the same mutation operation. To solve all kinds of problems with the global best solution, researchers proposed a new method by using additional variables to control the crosser and variation factors. This method can ensure that the two key parameters jump within a specified range and that the best variation parameters can be obtained in the next solution.

In the JDE algorithm, the crossover factor is between the maximum and minimum values in the population, which is determined by a random control variable ${\tau }_1$. The factor CR is directly determined by random numbers, which can be affected by the control variables ${\tau }_2$. These key parameters are expressed as follows:

$$F_{i,G+1}=\{\begin{array}{c}{F}_l+ran{d}_1\ast F_u;if(ran{d}_2<{\tau }_1)\\ F_{i,G};otherwise\end{array};C{R}_{i,G+1}=\{\begin{array}{c}ran{d}_3;if(ran{d}_4<{\tau }_2)\\ C{R}_{i,G};otherwise\end{array}$$

(21)

where F represents the maximum and minimum values; ${\tau }_1$ and ${\tau }_2$ represent the possible adjustment functions of the mutation and the crossover factors, respectively; $ran{d}_1,ran{d}_2,ran{d}_3$, and $ran{d}_4$ are three different random numbers between $[0,1]$. We can control the corresponding variation and crossover factors by adopting adaptive adjustment.

(C2) JADE

The JADE algorithm is a new type of differential evolution algorithm proposed by scholars [49]. In the DE algorithm, mutations best/1 and best/2 may cause premature convergence because the best method mainly explores the local optimum value field space.

In the algorithm, a global population is generated by superimposing the current population on the parent population. Hypothesis: The mutated individual of the population is expressed as A, the current population is expressed as P, and the overall population is expressed as $(P+A)$. However, we must avoid exceeding the given population number caused by continuously increasing the number of populations. Therefore, once the overall population is achieved, we must randomly remove a population from $(P+A)$. The corresponding mutation operation can be expressed as:

$$U_i(t+1)=X_i^P\left(t\right)+F_1(X_{best}^P\left(t\right)-X_i^P\left(t\right))+F_2(X_{r1}\left(t\right)-X_{r2}^{PA}\left(t\right))$$

(22)

where $X_{best}^p\left(t\right),$ is randomly chosen as one of the top $100p\%$ individuals in the current population with $p\in (0,1]$, $r2$ represents the random selection from the population $(P+A)$, and $best$ represents the best fitness index of the entire population.

In JADE algorithm, the symmetry function, random uniform distribution and Cauchy random distribution are introduced to keep the diversity of the group, the crossover probability CR is a random uniform distribution number (standard deviation is $U_{CR}$, the average disturbance is 0.1), and the initial value of $U_{CR}$ is 0.5. Similarly, the variation factor F is generated by Cauchy random disturbance (local disturbance is UF and Range 0.1), and the initial value of $U_F$ is 0.5. Specifically, these key parameters can be expressed as follows:

$$\{\begin{array}{c}C{R}_i=rand{n}_i(u_{CR},0.1)\\ u_{CR}=(1-c)u_{CR}+c·mea{n}_A\left(S_{CR}\right)\\ mea{n}_A=\frac{{\sum }_{CR\in S_{CR}}{S}_{CR}}{N}\end{array};\begin{array}{cc}& \end{array}\{\begin{array}{c}{F}_i=rand{c}_i(u_F,0.1)\\ u_F=(1-c)u_F+c·mea{n}_L\left(S_F\right)\\ mea{n}_A=\frac{{\sum }_{F\in S_F}{F}^2}{{\sum }_{F\in S_F}F}\end{array}$$

(23)

where $randn$ represents the random distribution number, $randc$ represents the Cauchy random distribution, $mea{n}_A$ represents the average value, $mea{n}_L$ represents the Lehmer mean, and $S_{CR}$ and $S_F$ represent the corresponding mutation factor and crossover probability when the final individual result is a new population individual, respectively.

(C3) SADE

The SADE (Self-adaptive Differential Evolution) algorithm effectively combines various mutation strategies to increase the diversity of the system. The next generation of mutated individuals is generating by selecting the best individual from various individuals generated from three different mutation operations. In multiple mutation strategies, the best method has a high convergence rate, but the phenomenon of falling into local optima may occur. Additionally, the rand method has strong global detection ability. Therefore, the random mutation operation is the most basic principle used to avoid the phenomenon. At the beginning, researchers used two basic mutation operations, rand/1 and best/1. With the rapid development of basic differential evolution algorithms, the basic mutation operations are transformed into four types.

$$\begin{array}{c}\left(1\right)DE/rand/1:\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_{r1}\left(t\right)+F(X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \\ \left(2\right)DE/rand-best/1:\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_i\left(t\right)+F(X_{best}\left(t\right)-X_i\left(t\right))+F(X_{r1}\left(t\right)-X_{r2}\left(t\right)+X_{r3}\left(t\right)-X_{r4}\left(t\right))\hfill \\ \left(3\right)DE/rand/2:\hfill \\ \begin{array}{cc}& \end{array} V_i(t+1)=X_i\left(t\right)+F(X_{r1}\left(t\right)-X_i\left(t\right))+\lambda (X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \\ \left(4\right)DE/currrent-best/1:\hfill \\ \begin{array}{cc}& \end{array} U_i(t+1)=X_i\left(t\right)+F(X_{r1}\left(t\right)-X_i\left(t\right))+\lambda (X_{r2}\left(t\right)-X_{r3}\left(t\right))\hfill \end{array}$$

(24)

The selection probability of each mutation operation can be specifically described as:

$$\begin{array}{c}{p}_{k,G}=\frac{S_{k,G}}{{\sum }_{k=1}^K{S}_{k,G}}\hfill \\ Sk,G=\frac{{\sum }_{g=G-LP}^{G-1}nsk,g}{{\sum }_{g=G-LP}^{G-1}nsk,g+{\sum }_{g=G-LP}^{G-1}nfk,g}+\zeta ,(k=1,2,\dots k)\hfill \end{array}$$

(25)

where $ns$ and $nf$ represent the number of successes and failures, respectively.

Again, the key parameter used in the next step is determined based on the success probability of various mutation operations. Then, the mutation and crossover factors are further optimized based on the NSDE algorithm to determine the key parameters. The mutation factor F is randomly selected, and the crossover factor is further determined by the success efficiency of various mutation parameters, which can be expressed as:

$$\begin{array}{c}F=Normrnd(0.5,0.3);\hfill \\ Rc=Normrnd(CRm,0.1);\hfill \end{array}$$

(26)

where $Normrnd$ represents the symmetry function is—random normal distribution.

(C4) ISAMDE

The ISAMDE algorithm combines the AMDE and adaptive scaling factor AF strategies. The AMDE strategy is same as that of the AMDE (A4) algorithm mentioned above. The AF strategy improves the performance of the DE algorithm by considering the current iteration number and error value: it can effectively balance the exploration and exploitation abilities of the algorithm. At the beginning of the iteration, the scaling factor is assigned a value of one, so the exploration ability is strong. The error value is affected by the current iteration number of the algorithm, which is less than the set value $E_0$. The AF can be expressed as:

$$AF=\{\begin{array}{cc}ϵ{\left(t\right)}^2·2·{10}^{-6}+0.5,\hfill & ϵ<E_0\hfill \\ 1,\hfill & otherwise\hfill \end{array}$$

(27)

where $ϵ\left(t\right)$ represents the error, and the value of $E_0$ is related to the specific engineering problems.

(C5) ENMDE

The ENMDE algorithm combines the self-tuned mutation strategy with the leading group selection strategy. The self-tuned mutation strategy includes four typical DE algorithms: DE/rand/1, DE/best/1, DE/rand/2, and DE/best/2. The TDE algorithms can be divided into two groups: the rand group, which includes DE/rand/1 and DE/rand/2; and the best group, which includes DE/best/1 and DE/best/2. The rand and best groups are selected by comparing the fitness distance ratio with the average fitness distance ratio. They are expressed as follows:

$$\Delta F{T}_d=\frac{F{T}_d-F{T}_{best}}{F{T}_{best}}$$

(28)

$$\Delta F{T}_{mean}=\frac{\frac{\left({\sum }_{d=1}^{N_p}F{T}_d\right)}{N_p}-F{T}_{best}}{F{T}_{best}}$$

(29)

where $\Delta F{T}_{mean}$ represents the average fitness distance ratio; $\Delta F{T}_d$ represents the fitness distance ratio; $F{T}_d$ represents the fitness function of the solution under consideration d; $N_p$ represents the population size; $F{T}_{best}$ represents the fitness function of the best solution; $F{T}_{mean}$ represents the mean value of all individuals’ fitnesses. The process of self-tuned mutation is described in detail in the following table. After the group is selected, the final mutation strategy is selected by considering the mutation mode factor (MMF). The specific process is expressed as

Table 1. The pseudocode of self-tuned mutation strategy.

	Self-Tuned Mutation
If	$\Delta F{T}_d$ >$\Delta F{T}_{mean}$
	if $rand>MMF$
	$v=x_{r1}+F(x_{r2}-x_{r3})$
	else
	$v=x_{r1}+F(x_{r2}-x_{r3}+x_{r4}-x_{r5})$
	end
else
	if $rand>MMF$
	$v=x_{best}+F(x_{r2}-x_{r3})$
	else
	$v=x_{best}+F(x_{r2}-x_{r3}+x_{r4}-x_{r5})$
	end
end

:

The leading group selection strategy is also used in this improved DE algorithm, where the individuals $x=[x_1,x_2,\dots ,x_{NP}]$ and $u=[u_1,u_2,\dots ,u_{Np}]$ are integrated into a new swarm, and then Np best solutions are selected and assigened to x, where u represents the individual are operated after crossover.

(C6) PDcDE

In the PDcDE algorithm, the swarm size is auto-controlled, the population is divided into two subpopulation–$N_1$,$N_2$, the best $N_1$ individuals are used to exploit new solution and the left $N_2$ individuals are used to explore new solution. The mutatant strategies are formulated as:

$$V_1=X_{1st}^{r1}+F_1·(X_{1st}^{r2}\left(t\right)-X_{1st}^{r3}\left(t\right))$$

(30)

$$V_2=X_{1st}^{r4}+F_2·(X^{r5}\left(t\right)-X^{r6}\left(t\right))$$

(31)

where $1st$ represents the individuals which are selected from the first group ($N_1$). $r1$, $r2$, $r3$, $r4$, $r5$ and $r6$ are randomly generated different indices, $r1$, $r2$ and $r3$ are selected from the first subpopulation ($N_1$), while $r4$, $r5$, $r6$ are selected from the whole population. The swarm size N is dynamically changed by considering whether the current best solution is updated or not, if it updated, a parameter $c^{-}$ is used to count by increasing one, when it reached a preset threshod value L, the worst individual will be removed until the swarm size reach the minimum size $N_{min}$. If the current best solution is not updated, a parameter $c^{+}$ is also used to count by increasing one, when it reaches a preset threshod value L, a randomly individual is introduced into the swarm until the swarm size reaches the maximum size $N_{max}$. The diversity-controlled paremeter setting is another strategy in the PDcDE algorithm, the scale $F_1$ and $F_2$ are for the $N_1$ subpopulation and $N_2$ subpopulation, respectively. They are dynamically generated by considering the population diversity. The diversity at the jth dimension is expressed as:

$$Di{v}^j=\frac{1}{N}\sqrt{\sum _{i=1}^N\left(\right||X_i^j-\overline{X^j}{\left|\right|)}^2}$$

(32)

$$\overline{X^j}=\frac{1}{N}\sum _{i=1}^N{X}_i^j$$

(33)

where $Di{v}^j$ represents the diversity of the swarm at the jth dimension. $X_i^j$ represnts the jth element in the ith individual. $\overline{X^j}$ represents the arithmetic mean of the swarm at jth dimension. The scale factors of $F_1^j$ and $F_2^j$ are expressed as:

$$F_1^j=\frac{Di{v}_1^j}{Di{v}_1^j+Di{v}_2^j}$$

(34)

$$F_2^j=\frac{Di{v}_2^j}{Di{v}_1^j+Di{v}_2^j}$$

(35)

where $Di{v}_1^j$ and $Di{v}_2^j$ represents the population diversity of the $N_1$ group and $N_2$ group, respectively.

The characteristic of diversity will lead the swarm search in different way, if the diversity is large, the swarm will search and explore in the large search space, conversely, if the diversity is small, the swarm will search and exploit in a small search space.

Finally, a backward search strategy is also proposed, it replaces the crossover solution if current best solution is not updated in successive L iteration, the formulations can be expressed as:

$$U^i\left(t\right)=V^i\left(t\right)+(rand-0.5)·r$$

(36)

$$r=V^i\left(t\right)-X^{best}\left(t\right)$$

(37)

where $U^i\left(t\right)$ is a trial solution, $V^i\left(t\right)$ representes the muatated solution in current generation, the rand is generated between 0 and 1.

The parameters F and CR which are needed to be set for variation and crossover in the JADE algorithm can be selected adaptively without artificial setting. The algorithm sometimes need enough iteration times and population size to obtain the optimal solution. It performs better in solving high-dimension problems but weak in dealing with low-dimension problems. JADE’s performance depends heavily on the setting of parameters, and different parameter settings may lead to different results. Due to the parameter F or CR are changed, the convergence accuracies of JDE, SADE, and PDcDE are high; however, the convergence rate sometimes are slow for the computational complexity. The stability of the PDcDE algorithm is high; however, the algorithm contains many redundant calculations. Because the rand strategy or best strategy of ENMDE are adaptive, the algorithm shows high precision. However, the calculation time sometimes maybe long for the complex judgment process. The influence of dynamically swarm size on the calculation results are uncertain. The ISAMDE usually shows better convergence rate and precision for taking advantage of the AMDE, however, sometimes the scale factor F and other parameters are difficult to set, the performance of the algorithm is largely depends on parameter settings, different parameter settings may lead to different results. So the scale factor and other parameters are always set based on experience.

3.3. Comparison of DE Algorithms

The above-mentioned DE algorithms mainly involve four basic parameters: the crosser coefficient, crosser operation, population size, and coefficient of variation. NP indicates the number of collective individuals in the population, which is generally selected by the user. If the NP is larger, the diversity of the population increases, and the optimal solution is more likely to be obtained. However, the longer the calculated time, the lower the system’s convergence performance. If NP is too small, the diversity is lost, and the algorithm falls into a local optimal solution. The size of NP is generally selected as 5 to 10 times the individual dimension and cannot be less than 4; otherwise, the mutation operation cannot be completed. The larger the value of the variation factor F, the larger the disturbance amplitude of the differential vector, the lower the population diversity, and the local minimum is arbitrarily found. When F is larger, the disturbance of the two sets is larger, and the rapid convergence of the system cannot be guaranteed. F is generally selected according to experience, ranging in value between 0 and 1, with a general value is 0.5. CR represents the proportion of mutated individuals. When CR is small, fewer individuals are mutated. The parent individuals can be maintained to ensure a slower convergence rate. When CR is larger, the proportion of the number of mutation sets is larger, which can improve the system’s local exploration and acceleration convergence. The value of CR ranges between 0 and 1. To fully understand the improvements of various algorithms, we compared the improvements of various differential evolution algorithms, and the results are shown in

Table 2. Specific optimization content of different DE algorithms.

Name		Initial Population	Variation Factor	Crossover Probability	Mutation Operator	Crossover Operator
A1	TDE	――	――	――	Optimize	Optimize
A2	ODE	Optimize	――	――	――	――
A3	CODE	――	Optimize	――	Optimize	――
A4	AMDE	――	――	――	Optimize	Optimize
B1	NSDE	――	Optimize	――	――	――
C1	JDE	Optimize	Optimize	Optimize	――	――
C2	JADE	――	Optimize	Optimize	Optimize	――
C3	SADE	――	Optimize	Optimize	Optimize	――
C4	ISAMDE	――	Optimize	――	Optimize	――
C5	ENMDE	――	――	Optimize	Optimize	――
C6	PDcDE	――	Optimize	――	Optimize	――

.

4. Solving Inverse Kinematics with DE Algorithm

To obtain the IK solution, in this section, we redefine the fitness parameters according to the specific requirements of the task and summarize the specific process and basic steps of the DE algorithm.

4.1. Redefine Inverse Kinematics of Mobile Manipulator

To move a mobile manipulator’s end to a target task point $X_t$, the corresponding angle needs to be obtained by solving the IK solution of the robot. However, due to the extreme redundancy and high DOFs of the manipulator, most traditional solution strategies for fixed manipulator can no longer be effectively applied to mobile manipulator robots. We assume that the position and posture information of the given task at the end is:

$$T_d={[R,P;0,1]}^T$$

(38)

where R represents the end posture of the robot, and $P={[Px,Py,Pz]}^T$ represents the end position.

The corresponding driving joint angle solved by the inverse kinematics of the mobile manipulator can be expressed as $q=(d_x,d_y,q_z,q_1,q_2,\dots ,q_n)$. When the robot moves to the joint angle, the error between the end of the mobile manipulator and the desired specified point can be expressed as:

$$Error=T_d-T_e\left(q\right)=[O_{er},P_{er};0_{1\ast 3},1]$$

(39)

where $T_e$ represents the forward kinematics of the robot, $O_{er}$ represents the posture error, and $P_{er}$ represents the position error.

For the same specified position and posture, many different combinations of joint angles can be used to control the mobile manipulator to move to the specified point. Therefore, these joint angles can be directly defined as a solution set, which is expressed as follows:

$$C_s=\left[\begin{array}{ccccccccc}{d}_x^1& d_y^1& q_z^1& q_1^1& \hspace{0.17em}& q_2^1& \dots & \dots & q_n^1\\ d_x^2& d_y^2& q_z^2& q_1^2& \hspace{0.17em}& q_2^2& \dots & \dots & q_n^2\\ \dots & \dots & \dots & \dots & \hspace{0.17em}& \dots & \dots & \dots & \dots \\ d_x^j& d_y^j& q_z^j& q_1^j& \hspace{0.17em}& q_2^j& \dots & \dots & q_n^j\end{array}\right]$$

(40)

where $C_s$ represents the overall set of solution results, and j represents the number of iteration times.

When the given task is at a specified position, the inverse kinematics solution can be directly defined as an error function. Therefore, the IK problem of the robot can be re-expressed as finding the combination of drive joint angles within the limited range to make the function reach the minimum value, namely:

$$sub:f\left(q\right)=min\parallel T_d-T_e\left(q\right)\parallel =0$$

(41)

where $f\left(\right)$ indicates the fitness function of a given mobile robotic arm, $T_d$ indicates the position and posture of a given task, and $T_e$ represents the actual position and posture.

Remark 5.

When the end position is individually given, and the state is not restricted, the IK can be expressed as:

$$\begin{array}{c}tar:f_1\left(q\right)=min\parallel P_d-P_e\left(q\right)\parallel \hfill \\ sub:q_i^L<q_i<q_i^U;\hfill \end{array}$$

(42)

where $f_1\left(\right)$ represents the fitness function, $P_d$ represents the desired position, $P_e$ represents the actual end position, and $q_i^L,q_i^U$ indicates the maximum and minimum driving joint positions.

Remark 6.

When the position and posture of the end of the mobile manipulator are all in a given state, the inverse kinematics problem can be expressed:

$$\begin{array}{c}tar:f_2\left(q\right)=min\left(\parallel P_d-P_e\left(q\right)\parallel +\parallel R_d-R_e\left(q\right)\parallel \right)\hfill \\ sub:q_i^L<q_i<q_i^U;\hfill \end{array}$$

(43)

where $f_2\left(\right)$ represents another fitness function, $\parallel R_d-R_e\left(q\right)\parallel$ represents the posture error value of the mobile manipulator’s end, and $\parallel P_d-P_e\left(q\right)\parallel$ represents the position error value.

Remark 7.

During actual movement, we need to choose a set of results as the best solution. To move to the specified position smoothly, the result with the smallest angle of change must be selected as the control of the robot’s motion. The problem can be directly defined as a selection function; specifically, it can be expressed as the smallest result in the current joint and the solution group. Therefore, we define the objective function as the function with the smallest joint angle and the smallest expected position error as:

$$\begin{array}{c}tar:f_3\left(q\right)=min(w_1\ast ({\parallel P_d-P_e\left(q\right)\parallel }_2+{\parallel R_d-R_e\left(q\right)\parallel }_2)+w_2\ast {\parallel p_n-p_o\parallel }_2)\hfill \\ sub:q_i^L<q_i<q_i^U;\hfill \end{array}$$

(44)

where $f_3\left(\right)$ indicates the other fitness function, $p_n$ indicates the driving joint angle obtained at the current time, and $p_o$ indicates the driving joint angle obtained at the previous time.

4.2. De Algorithm Code for Solving Inverse Kinematics

Different DE algorithms can be used to solve the IK problem. Although the key technologies of various DE algorithms are different, the basic process of solving inverse kinematics with these DE algorithms does not substantially differ and can be described as follows:

Step 1: Obtain the basic parameters of the mobile manipulator and set the target point of the robot.

Step 2: Initialize the basic parameters, which include population NP, number of iterations N, crossover factor CR, mutation probability F, and number of driving joints D.

Step 3: Initialize the population and calculate the fitness value of each individual in the group.

Step 4: Select the population according to the mutation operation to perform the mutation operation, and update the range of the new population.

Step 5: Generate new population individuals according to the crossover principle to complete the basic population evolution.

Step 6: Calculate the fitness function of the new individual and determine whether the population meets the conditions. If not, return to Step 4 to update the population again. If so, proceed to Step 7.

Step 7: Save the drive joint data and complete the joint solution. The flowchart of the DE algorithm used in solving the inverse kinematics is shown as Figure 2

5. Experimental Simulation

To compare the performance of the various differential evolution methods in solving mobile manipulator problems, we choose three typical mobile manipulator robots as the experimental objects, and we use random point tasks and continuous trajectory tasks. In the random point task, we set the position and posture of each random point to compare the various DE algorithms. For the continuous trajectory tasks, we separately set the position of each random point only to test the performance of the various DE algorithms. In addition, the control parameters are set on the best differential evolution method. To facilitate practical applications, the computer parameters used in this study are an Intel(R) Core(TM) i5-7500 CPU @3.4HZ, RAM @8G. Additionally, we calculate the statistics on the success rate and solution time of the various algorithms for solving inverse kinematics.

5.1. Equipment Description

Various DE algorithms are examined using three typical mobile manipulators with different DOFs. The control variable of the mobile-fixed coordinate frame can be expressed as $q_m={[d_x,d_y,q_z]}^T$, where $q_m$ represents the three virtual joints of the mobile robot, $d_x$ and $d_y$ are the translation joints, and $q_z$ is the rotation joint. The manipulator uses the typical manipulator robots as actuators, including KUKA5, UR5, and Robot7 as Figure 3; the corresponding joint control variables are $q_a=[q_1,q_2,\dots ,q_n]$. The structures of the different robots are shown in Figure 1, and the DH parameters of the corresponding manipulator robot are shown in

Table 3. Standard parameters of the manipulator subsystem.

5 Dof Arm				6 Dof Arm				7 Dof Arm
${\mathit{joint}}_{\mathit{i}}$	${\mathit{d}}_{\mathit{i}}$	${\mathit{a}}_{\mathit{i}}$	${\mathit{\alpha }}_{\mathit{i}}$	${\mathit{joint}}_{\mathit{i}}$	${\mathit{d}}_{\mathit{i}}$	${\mathit{a}}_{\mathit{i}}$	${\mathit{\alpha }}_{\mathit{i}}$	${\mathit{joint}}_{\mathit{i}}$	${\mathit{d}}_{\mathit{i}}$	${\mathit{a}}_{\mathit{i}}$	${\mathit{\alpha }}_{\mathit{i}}$
1	0.147	0.033	$\pi /2$	1	0.895	0	$-\pi /2$	1	0.360	0	$-\pi /2$
2	0.000	0.155	0	2	0	−0.425	0	2	0	0	$\pi /2$
3	0.000	0.135	0	3	0	−0.392	0	3	0.420	0	$-\pi /2$
4	0.000	0.000	$-\pi /2$	4	1.092	0	$\pi /2$	4	0	0	$\pi /2$
5	0.000	0.000	0	5	0.947	0	$-\pi /2$	5	0.400	0	$-\pi /2$
―	―	―	―	6	0.823	0	0	6	0	0	$\pi /2$
―	―	―	―	―	―	―	―	7	0.126	0	0

.

When we establish the gravity center at the coordinate system of the mobile platform, the distances from the base-fixed coordinate frame to the mobile-fixed coordinate frame are dx1, dy2, dz3, dx1, dy2, dz3, dx1, dy2, dz3. Therefore, the homogeneous matrix from the center position to the end could be expressed as:

$$T_{cb}^1=\left[\begin{array}{cccc}1& 0& 0& 0.167\\ 0& 1& 0& 0.000\\ 0& 0& 1& 0.225\\ 0& 0& 0& 1\end{array}\right];T_{cb}^2=\left[\begin{array}{cccc}1& 0& 0& 0.450\\ 0& 1& 0& 0.000\\ 0& 0& 1& 0.325\\ 0& 0& 0& 1\end{array}\right];T_{cb}^3=\left[\begin{array}{cccc}1& 0& 0& 0.450\\ 0& 1& 0& 0.000\\ 0& 0& 1& 0.325\\ 0& 0& 0& 1\end{array}\right]$$

(45)

At the initial moment, the position of the mobile platform is set to (0, 0, 0), the angles of the first manipulator subsystem are set to (0, 0, 0, 0, 0), the angles of the second manipulator subsystem are set to (0, 0, 0, 0, 0, 0), and the initial angles of the third manipulator subsystem are to as (0, 0, 0, 0, 0, 0, 0). In this case, the corresponding limit ranges of the mobile manipulator are, respectively, expressed as:

$$Robot1:\{\begin{array}{c}{q}^L=\left[-1.5,-1.5,-\mathrm{pi},-169,-65,-150,-102.5,-167.5\right]\\ q^U=\left[+1.5,+1.5,+\mathrm{pi},+169,+90,+146,+102.5,+167.5\right]\end{array}$$

(46)

$$Robot2:\{\begin{array}{c}{q}^L=\left[-1.5,-1.5,-\mathrm{pi},-169,-165,-150,-102.5,-167.5,-167.5\right]\\ q^U=\left[+1.5,+1.5,+\mathrm{pi},+169,+165,+150,+102.5,+167.5,+167.5\right]\end{array}$$

(47)

$$Robot3:\{\begin{array}{c}{q}^L=\left[-1.5,-1.5,-\mathrm{pi},-169,-120,-170,-120,-170,-120,-170\right]\\ q^U=\left[+1.5,+1.5,+\mathrm{pi},+169,+120,+170,+120,+170,+120,+170\right]\end{array}$$

(48)

5.2. The Best Differential Evolution Test

The problem dimension D is set according to the number of driving joints of the mobile manipulator. The dimensions for robot1, robot2, and robot3 are 8, 9, and 10, respectively. The maximum number of iterations is set to $G=1000$. When the error between the solution result and the actual task is less than ${10}^{-8}$, the error value is set to 0, and the robot could successfully complete the task point, so then needed to solve the next task point. Most control parameters of these DE algorithms are set to the same value as in the original study, and each algorithm’s control parameter settings are shown in

Table 4. The parameter settings for each DE algorithm.

Name	Number	Parameter Setting
rand1	01	$G=1000;NP=50;F=0.5;CR=0.9;$
best1	02	$G=1000;NP=50;F=0.5;CR=0.9;$
rand2	03	$G=1000;NP=50;F=0.5;CR=0.9;$
best2	04	$G=1000;NP=50;F=0.5;CR=0.9;$
cu-be	05	$G=1000;NP=50;F=0.5;CR=0.9;$
ODE	06	$G=1000;NP=50;F=0.5;CR=0.9;$
CODE	07	$G=1000;NP=50;F=0.5;CR=0.9;$
AMDE	08	$G=1000;NP=50;F=[1.0,1.0,0.8];CR=[0.1,0.9,0.2];$
NSDE	09	$G=1000;NP=50;F=\left\{Normrnd\right(0.5,0.5\left)\right|\left|Cauchyrnd\right(1\left)\right\};CR=0.9;$
JDE	10	$G=1000;NP=50;F=0.1+0.9\ast rand;CR=rand;$
JADE	11	$G=1000;NP=50;Nb=5;uF=0.6;uCR=0.85;$
ISAMDE	12	$G=1000;NP=50;F=0.5;CR=0.9;$
ENMDE	13	$G=1000;NP=50;F=0.5;CR=1;MMF=0.25;$
PDcDE	14	$G=1000;NP=50;Nmax=55;Nmin=45;L=5;F=0.5;CR=0.9$

.

Where the parameter L in the ISAMDE algorithm is the threshold value. It is used to record the numbers of current best solution is updated and not updated.

5.2.1. Fixed Point Task

To test the performance of the various DE algorithms, we first randomly design 100 target points (Task 1) without the mobile platform’s movement as the study objects. The given target point contained position and posture information; we specifically compare the performance of the various algorithms. To ensure that the target point is in the working space of the robot, we use the Monte Carlo method to generate multiple random numbers within the given joint angle constraints. To test the performance regarding inverse kinematics, we first determine many driving joint angles by randomly selecting from among the given angle range. Then, the position and posture of the fixed-point tasks are generated by the forward kinematics of the mobile manipulator robot, which could be expressed as:

$$\{\begin{array}{c}{T}_e=FK(d_x,d_y,q_z,q_1,q_2,\dots ,q_n)\\ dx=dy=dz=0\\ q_i=ql\left(i\right)+(q_u\left(i\right)-q_l\left(i\right))\ast rand\end{array}$$

(49)

We perform multiple iterations on the fixed-point task. To simultaneously determine the above position and state, we choose the F2 fitness function to solve the calculation. To improve the efficiency of the solution, the final decision function F1 is transferred to the system. The specific parameters are expressed as:

$$\{\begin{array}{c}fit:F_2=f_2\left(q\right)\\ stop:F_1=f_1\left(q\right)\end{array}$$

(50)

The number of populations is set $NP$ = 50; F = 0.5, and $CR$ = 0.9; the corresponding number of iterations is G = 1000. We compare the various key parameters of inverse kinematics including the average time for each iteration; the error range, success rate of the solution, and the corresponding results are summarized in

Table 5. The basic results for solving inverse kinematics of the different mobile manipulator robots.

Name		Error			Time			Suc
Robot	DE	Min	Mean	Max	Min	Mean	Max	Suc
robot1	01	0	$1.2\times {10}^{-3}$	0.084	0.548	0.707	1.566	98
	02	0	$1.4\times {10}^{-2}$	0.266	0.086	0.368	1.657	84
	03	$1.1\times {10}^{-6}$	$1.0\times {10}^{-3}$	0.050	1.622	1.640	1.707	90
	04	0	$8.0\times {10}^{-3}$	0.251	0.289	0.484	1.725	91
	05	0	$1.2\times {10}^{-2}$	0.234	0.200	0.517	1.745	83
	06	0	$2.3\times {10}^{-3}$	0.171	0.627	0.806	1.977	98
	07	0	$1.9\times {10}^{-3}$	0.044	1.209	4.176	4.995	81
	08	0	$1.1\times {10}^{-2}$	0.179	0.215	0.444	1.703	87
	09	0	$1.3\times {10}^{-2}$	0.285	0.223	0.694	2.540	84
	10	0	$1.3\times {10}^{-2}$	0.200	0.184	0.556	1.719	83
	11	$5.9\times {10}^{-4}$	$9.0\times {10}^{-3}$	0.079	3.905	3.980	4.350	2
	12	0	$1.4\times {10}^{-3}$	0.155	0.210	0.259	0.740	97
	13	0	$8.7\times {10}^{-3}$	0.198	0.665	1.166	3.051	86
	14	0	$8.4\times {10}^{-3}$	0.230	0.439	0.703	1.822	94
robot2	01	$1.7\times {10}^{-7}$	$3.9\times {10}^{-4}$	0.058	0.765	1.045	1.808	99
	02	0	$5.9\times {10}^{-3}$	0.207	0.100	0.241	1.875	95
	03	$2.5\times {10}^{-3}$	$2.9\times {10}^{-2}$	0.265	1.859	1.888	1.942	3
	04	0	$3.5\times {10}^{-3}$	0.467	0.375	0.520	1.936	99
	05	0	$9.3\times {10}^{-3}$	0.310	0.163	0.353	1.941	93
	06	0	$1.4\times {10}^{-7}$	9.359	0.856	1.113	1.992	100
	07	0	$3.2\times {10}^{-4}$	0.011	1.179	4.389	5.650	92
	08	0	$6.3\times {10}^{-3}$	0.292	0.303	0.428	1.931	95
	09	0	$6.8\times {10}^{-3}$	0.195	0.255	0.536	2.797	94
	10	0	$3.9\times {10}^{-3}$	0.427	0.224	0.402	1.923	98
	11	$1.4\times {10}^{-3}$	$1.5\times {10}^{-2}$	0.057	4.294	4.373	4.529	0
	12	0	0	0	0.275	0.321	0.525	100
	13	0	$3.3\times {10}^{-3}$	0.192	0.893	1.256	3.609	93
	14	0	$8.1\times {10}^{-3}$	0.419	0.478	0.824	2.389	95
robot3	01	0	$1.2\times {10}^{-5}$	$1.2\times {10}^{-3}$	1.097	1.411	1.952	99
	02	0	0	0	0.126	0.180	0.824	100
	03	$1.7\times {10}^{-3}$	$1.5\times {10}^{-1}$	$3.1\times {10}^{-1}$	2.068	2.087	2.156	0
	04	0	$2.7\times {10}^{-5}$	$2.7\times {10}^{-3}$	0.211	0.316	2.133	99
	05	0	$4.8\times {10}^{-4}$	$4.4\times {10}^{-2}$	0.310	0.484	2.108	98
	06	0	$1.1\times {10}^{-5}$	$1.1\times {10}^{-3}$	1.096	1.432	2.386	99
	07	$6.1\times {10}^{-1}$	2.5	5.0	5.883	5.950	6.456	0
	08	0	0	0	0.140	0.181	0.675	100
	09	0	0	0	0.315	0.447	2.515	100
	10	0	$6.5\times {10}^{-6}$	$5.5\times {10}^{-4}$	0.147	0.327	1.265	98
	11	$1.3\times {10}^{-3}$	$1.1\times {10}^{-2}$	$3.7\times {10}^{-2}$	4.435	4.539	4.691	0
	12	0	$1.0\times {10}^{-6}$	$7.5\times {10}^{-5}$	0.336	0.394	0.812	99
	13	0	$3.0\times {10}^{-4}$	$2.2\times {10}^{-2}$	1.038	1.491	4.163	93
	14	0	$2.9\times {10}^{-6}$	$2.6\times {10}^{-4}$	0.483	0.792	2.122	98

.

The results of the first simulation for the manipulators with different degrees of freedom are shown in Figure 4. Given these 100 random task points including posture and position, we compare the total error and calculation time. We obtain the following results:

(1)

A comparison of the total error in Figure 4a,c,e and Table 5 show that the success rate of the inverse kinematics solution for random points continue to increase with the continuous increase in the DOFs. Therefore, the high-DOF robot could more smoothly complete the complex task.

(2)

A comparison of the times in Figure 4b,d,f show that in most situations, the calculation speed of best1, best2, cube, AMDE, NSDE, JDE and ISAMDE are faster when solving random task points. The above methods are relatively close in time. The inverse kinematics mean time of robot1, robot2, and robot3 takes near 0.2 s, 0.4 s, 0.5 s, respectively. On the contrary, CODE and JADE need the longest time to produce a solution, and the mean time for robot1, robot2, and robot3 to obtain a solution are longer than 2 s. Follow the best1, best2, cube, AMDE, NSDE, JDE and ISAMDE algorithm, the PDcDE algorithm shows faster convergence rate and less time comsumption than the other algorithms for robot1, robot2 and robot3. Then, rand1, ODE and ENMDE are located at the third level, requiring 0.8 s, 1 s, and 1.5 s to solve the tasks for robot1, robot2, and robot3, respectively.

Where 12, 13, 14 in the Figure 4 represent “ISAMDE”, “ENMDE” and “PDcDE”, respectively.

5.2.2. Trajectory Tracking Test

Because the mobile manipulator need to complete different tasks, the test results of a single fixed point could complete the continuous performance test. Therefore, we choose two typical motion trajectories to compare the energy absorption of the IK of the mobile robot. The first trajectory is a simple COS trajectory (Task 2), and the second one is a complex spiral trajectory (Task 3), which is shown in Figure 5. The mathematical expression of these trajectoriess can be expressed as:

$$\{\begin{array}{c}{x}_1^a=0.5\\ y_1^a=t/N\\ z_1^a=0.4+0.15cos(4\pi t/N)\end{array};\{\begin{array}{c}{x}_2^a=0.5\\ y_2^a=t/N\\ z_2^a=0.8+0.15cos(4\pi t/N)\end{array};\{\begin{array}{c}{x}_3^a=0.5\\ y_3^a=t/N\\ z_3^a=0.9+0.15cos(4\pi t/N)\end{array}$$

(51)

$$\{\begin{array}{c}{x}_1^b=t/N\\ y_1^b=0.15sin(4\pi t/N)\\ z_1^b=0.4+0.15cos(4\pi t/N)\end{array};\{\begin{array}{c}{x}_2^b=t/N\\ y_2^b=0.15sin(4\pi t/N)\\ z_2^b=0.8+0.15cos(4\pi t/N)\end{array};\{\begin{array}{c}{x}_3^b=t/N\\ y_3^b=0.15sin(4\pi t/N)\\ z_3^b=0.9+0.15cos(4\pi t/N)\end{array}$$

(52)

where $x_i^a,y_i^a,z_i^a$ represents the position of the first desired trajectory corresponding to the i-th mobile manipulator robot, $x_i^b,y_i^b,z_i^b$ represents the position of the second desired trajectory corresponding to the ith mobile manipulator robot, t = 1 s indicates the movement time for the desired trajectory, and $N=200$ indicates the segmentation result for the desired trajectory.

For the first trajectory, we use the same parameters as in the first task (Task 1), which we design to compare the solution error and solution efficiency of these DE algorithms. Because the position requirement is without the posture requirement, the fitness function we used in the second task needed to be transformed, which could be specifically expressed as:

$$\{\begin{array}{c}fit:F_2=f_3\left(q\right)\\ stop:F_1=f_1\left(q\right)\end{array}$$

(53)

where $f_3\left(\right)$ represents the minimum function of the sum of the position error and joint movement, and $f_1\left(\right)$ is the function that represents the smallest sum of the position errors.

The results of the task 2 simulation experiment for simple trajectory tracking are shown as

Table 6. The comparison results of the first trajectory tracking for different mobile manipulator robots.

Name		Error			Time			Suc
Robot	DE	Min	Mean	Max	Min	Mean	Max	Suc
	01	0	0	0	0.095	0.118	0.234	200
	02	0	0	0	0.070	0.113	0.273	200
	03	0	0	0	0.684	0.833	0.957	200
	04	0	0	0	0.168	0.224	0.319	200
	05	0	$1\times {10}^{-4}$	$3.4\times {10}^{-3}$	0.114	0.461	1.620	161
	06	0	0	0	0.330	0.442	1.477	200
robot1	07	0	$1.2\times {10}^{-7}$	$4.3\times {10}^{-6}$	1.031	1.971	4.713	162
	08	0	0	0	0.141	0.182	0.532	200
	09	0	0	0	0.161	0.281	0.751	200
	10	0	0	0	0.123	0.236	1.055	200
	11	0	$4.0\times {10}^{-4}$	$6.1\times {10}^{-3}$	3.777	3.831	3.969	0
	12	0	0	0	0.110	0.153	0.323	200
	13	0	$4.6\times {10}^{-9}$	$9.2\times {10}^{-7}$	0.330	0.604	1.872	199
	14	0	$4.5\times {10}^{-8}$	$3.8\times {10}^{-6}$	0.364	0.676	1.706	196
	01	0	$8.9\times {10}^{-9}$	$1.7\times {10}^{-6}$	0.517	0.642	1.844	199
	02	0	0	0	0.104	0.302	1.093	200
	03	0	$6.1\times {10}^{-5}$	$1.2\times {10}^{-2}$	1.315	1.568	1.881	198
	04	0	0	0	0.292	0.387	1.240	200
	05	0	$3.3\times {10}^{-6}$	$1.7\times {10}^{-4}$	0.189	0.603	1.839	194
	06	0	0	0	0.576	0.739	2.048	200
robot2	07	0	$3.0\times {10}^{-7}$	$1.1\times {10}^{-5}$	0.991	3.006	5.155	140
	08	0	0	0	0.217	0.370	1.605	200
	09	0	0	0	0.277	0.722	1.742	200
	10	0	$6.5\times {10}^{-8}$	$1.1\times {10}^{-5}$	0.280	0.679	1.875	198
	11	$3.0\times {10}^{-4}$	$6.4\times {10}^{-3}$	$7.0\times {10}^{-2}$	4.094	4.147	4.29	0
	12	0	0	0	0.166	0.207	0.571	200
	13	0	$8.8\times {10}^{-3}$	$8.0\times {10}^{-2}$	0.833	3.051	3.566	23
	14	0	$1.2\times {10}^{-5}$	$4.1\times {10}^{-4}$	0.484	1.298	2.164	113
	01	0	0	0	0.532	0.679	1.388	200
	02	0	0	0	0.118	0.301	0.748	200
	03	0	$4.3\times {10}^{-8}$	$8.6\times {10}^{-6}$	1.338	1.717	2.010	198
	04	0	$6.0\times {10}^{-4}$	$4.4\times {10}^{-2}$	0.193	0.848	1.966	164
	05	0	$4.0\times {10}^{-4}$	$4.4\times {10}^{-2}$	0.188	1.177	2.034	118
	06	0	0	0	0.571	0.718	1.792	200
	07	0	$5.6\times {10}^{-8}$	$3.7\times {10}^{-6}$	1.805	2.691	5.806	183
robot3	08	0	0	0	0.478	0.697	1.998	200
	09	0	0	0	0.303	0.664	2.344	200
	10	0	$5.1\times {10}^{-7}$	$6.1\times {10}^{-5}$	0.212	0.589	1.238	194
	11	$1.0\times {10}^{-4}$	$2.8\times {10}^{-3}$	$1.3\times {10}^{-2}$	4.348	4.407	4.540	0
	12	0	0	0	0.162	0.199	0.394	200
	13	0	$7.1\times {10}^{-3}$	$1.1\times {10}^{-1}$	0.968	3.555	4.114	17
	14	0	$2.4\times {10}^{-5}$	$7.9\times {10}^{-4}$	0.595	1.300	1.951	80

. The trajectory tracking error and time required for the first trajectory tracking by the robots with different degrees of freedom are compared. Where Suc represents the numbers of success solution in the 200 trajectory points. By comparing these results, we obtained the following:

(1)

The total error shows that the tracking precision of the specified task point after moving the end of the robot arm substantially increased. The success rates of the cube, CODE and JADE algorithms for the IK problem of robot1 are lower than those of the other DE algorithms; the success rates of CODE, JADE, ENMDE, and PDcDE for the IK problem of robot2 are lower than those of the other DE algorithms; the success rates of cube, JADE, ENMDE and PDcDE for the inverse kinematics of robot3 are lower than those of the other DE algorithms.

(2)

Comparing the solution mean time in Table 6 shows that best1 and ISAMDE have better performance for the IK of all robots. However, CODE, JADE and ENMDE perform worse for the inverse kinematics of all robots. Additionally, the solution performance of the other algorithms for the different robots are in between.

For the second trajectory, we use the same parameters as in Task 2, which we design for the various DE algorithms to compare their solution error and solution efficiency. The results of the third simulation experiment for the complex trajectory tracking task are shown in

Table 7. The comparison results of the second trajectory tracking for different mobile manipulator robots.

Name		Error			Time			Suc
Robot	DE	Min	Mean	Max	Min	Mean	Max	Suc
	01	0	0	0	0.286	0.360	0.466	200
	02	0	0	0	0.065	0.108	0.299	200
	03	0	0	0	0.644	0.804	0.923	200
	04	0	0	0	0.764	0.625	0.879	200
	05	0	$1.0\times {10}^{-4}$	$9.8\times {10}^{-3}$	0.113	0.398	1.747	171
	06	0	0	0	0.354	0.414	0.738	200
	07	0	$1.5\times {10}^{-7}$	$3.8\times {10}^{-6}$	1.039	2.143	4.852	151
robot1	08	0	0	0	0.139	0.177	0.355	200
	09	0	0	0	0.170	0.264	0.527	200
	10	0	0	0	0.121	0.247	0.725	200
	11	$4.3\times {10}^{-7}$	$1.5\times {10}^{-5}$	$7.1\times {10}^{-4}$	3.819	3.863	3.967	0
	12	0	0	0	0.121	0.158	0.354	200
	13	0	$1.0\times {10}^{-4}$	$3.7\times {10}^{-3}$	0.534	1.644	2.818	115
	14	0	$5.6\times {10}^{-8}$	$5.0\times {10}^{-6}$	0.384	0.743	1.869	194
	01	0	0	0	0.518	0.629	1.021	200
	02	0	0	0	0.115	0.290	0.851	200
	03	0	7.1$\times {10}^{-8}$	$1.3\times {10}^{-5}$	1.265	1.541	1.855	194
	04	0	$2.4\times {10}^{-4}$	$1.9\times {10}^{-2}$	0.287	0.420	1.860	196
	05	0	0	$3.8\times {10}^{-3}$	0.165	0.587	1.825	197
	06	0	$6.1\times {10}^{-9}$	$1.2\times {10}^{-6}$	0.591	0.774	2.244	199
	07	0	$3.7\times {10}^{-7}$	$1.8\times {10}^{-5}$	1.430	2.925	5.188	150
robot2	08	0	0	0	0.232	0.356	1.092	200
	09	0	0	0	0.352	0.725	1.792	200
	10	0	$1.7\times {10}^{-8}$	$3.5\times {10}^{-6}$	0.296	0.622	1.859	199
	11	$2.0\times {10}^{-4}$	$6.9\times {10}^{-3}$	$3.8\times {10}^{-2}$	4.095	4.151	4.304	0
	12	0	0	0	0.166	0.200	0.381	200
	13	0	$7.9\times {10}^{-3}$	$8.1\times {10}^{-2}$	0.792	2.831	3.302	32
	14	0	$1.0\times {10}^{-4}$	$1.4\times {10}^{-2}$	0.594	1.243	1.861	104
	01	0	0	0	0.544	0.636	1.152	200
	02	0	0	0	0.124	0.325	1.128	200
	03	0	$8.4\times {10}^{-9}$	$1.6\times {10}^{-6}$	1.439	1.691	1.982	199
	04	0	$5.0\times {10}^{-4}$	$2.9\times {10}^{-2}$	0.181	0.736	2.023	183
	05	0	$8.6\times {10}^{-4}$	$3.8\times {10}^{-2}$	0.199	1.304	2.033	96
	06	0	0	0	0.566	0.716	1.623	200
	07	0	$8.4\times {10}^{-8}$	$3.0\times {10}^{-6}$	1.741	2.727	5.689	175
robot3	08	0	0	0	0.234	0.330	0.605	200
	09	0	0	0	0.282	0.618	1.732	200
	10	0	$3.7\times {10}^{-6}$	$5.5\times {10}^{-4}$	0.185	0.557	1.177	193
	11	$4.0\times {10}^{-3}$	$5.6\times {10}^{-3}$	$3.3\times {10}^{-2}$	4.229	4.410	4.932	0
	12	0	0	0	0.161	0.191	0.352	200
	13	0	$9.0\times {10}^{-3}$	$1.0\times {10}^{-1}$	1.034	3.495	4.353	20
	14	0	$2.1\times {10}^{-5}$	$1.9\times {10}^{-3}$	0.656	1.304	1.924	107

. The trajectory tracking error and overall time-consuming tactics of the mobile manipulators with different degrees of freedom are presented. We obtain the following:

(1)

Comparing the error parameters in Table 6 and Table 7, we find that the success rate and error of these DE algorithms for solving the medium-complexity trajectory tracking task are widely different. This is caused by the DOFs of the robot and the complexity of the task points. The error range of the various algorithms for robot2 narrowed, but the solution error of best2, cube, and JADE algorithm increases.

(2)

By comparing the calculation speeds (mean time) shown in Table 7, we find that best1, AMDE and ISAMDE perform the best, the mean time of the three algorithms are less than 0.5 s for all the robots; CODE, JADE and ENMDE perform the worst, in most situations, the mean time are more than 2 s. The solution performance of the other algorithms for the different robots is between the best DE algorithms and worst DE algorithms.

(3)

A comparison of the solution time and overall error in Table 7 shows that the solution performance of the different methods differ for the different robots. JADE and ENMDE perform worst on all robots, rand1, best1, AMDE and ISAMDE perform the best on all robots.

5.3. Optimization of Best DE Algorithm

In various differential evolution algorithms, mutation operators and crossover operators are important factors for the algorithm. However, for the determined optimal DE algorithm, mutation operators and crossover operators are fixed parameters. We have determined the best DE method for solving the IK of mobile manipulators with different DOFs. As we generally known, the best DE algorithm will also be affected by the crossover probability and mutation factor in the solution process. To further improve the best DE, we can consider the specific impact of the control parameters and population size. Therefore, we optimize the performance of the best differential evolution algorithm for the IK problem of various mobile manipulators based on the selection of the control parameters and population size. The parameter optimization process applies to all algorithms. In this paper, we select the best DE algorithm to compare and introduce the optimization process. The process of determining the best DE algorithm can be described as: Firstly, compare the success rate in the fixed task (Table 5), the more DOFs of robot has, the more complex of solving process will be. If the solution of one algorithm is outperform in solving complex problem, the algorithm is better. So we analyse the performance of robot and choose the best performance of all the algorithms as the best DE algorithm. Then, compare the maximum value of error, if the error is smaller, the algorithm is better, finally, compare the maximum time, if the time is smaller, the algorithm is better. In this way, we select the AMDE algorithm as the best DE algorithm.

5.3.1. Variation Factor

To determine the best mutation factor F, we select eleven parameters from [0–1.1] as the mutation factor F and studied the effect of the mutation factor on the performance of the best differential evolution algorithm for solving the inverse kinematics. Then, we choose task 3 as the typical trajectory to be tracked, and the rest of the parameter settings remain unchanged except for the CR, which is set to 0.9. The total error and time used to solve the problem of the different variation factors are shown in

Table 8. Influence of crossover factor on best DE algorithm with $CR$ = 0.9, 5 DOF robot arm (robot1), 6 DOF robot arm (robot2), 7 DOF robot arm (robot3).

Name		Error			Time			Suc
Robot	F	Min	Mean	Max	Min	Mean	Max	Suc
	0.1	0	$2.1\times {10}^{-2}$	$3.1\times {10}^{-1}$	0.037	1.444	3.057	19
	0.2	0	$4.7\times {10}^{-3}$	$1.1\times {10}^{-1}$	0.052	0.743	2.774	126
	0.3	0	0	0	0.093	0.299	1.119	200
	0.4	0	0	0	0.099	0.159	0.365	200
	0.5	0	0	0	0.140	0.177	0.266	200
robot1	0.6	0	0	0	0.201	0.278	0.632	200
	0.7	0	0	0	0.308	0.434	1.098	200
	0.8	0	0	0	0.552	0.665	0.795	200
	0.9	0	0	0	0.766	1.062	1.232	200
	1	0	$2.0\times {10}^{-4}$	$2.8\times {10}^{-2}$	0.648	1.499	1.607	24
	1.1	0	$9.5\times {10}^{-6}$	$7.8\times {10}^{-5}$	1.533	1.613	3.295	2
	0.1	0	$1.3\times {10}^{-2}$	$3.2\times {10}^{-1}$	0.043	1.241	1.985	67
	0.2	0	$1.0\times {10}^{-4}$	$9.7\times {10}^{-3}$	0.080	0.467	1.906	181
	0.3	0	0	0	0.131	0.405	1.086	200
	0.4	0	0	0	0.053	0.194	0.526	200
	0.5	0	0	0	0.228	0.392	1.119	200
robot2	0.6	0	0	0	0.353	0.437	1.407	200
	0.7	0	0	0	0.599	0.735	1.734	200
	0.8	0	0	0	1.000	1.237	1.482	200
	0.9	0	$5.1\times {10}^{-7}$	$5.1\times {10}^{-6}$	1.617	1.824	1.935	63
	1	0	$1.5\times {10}^{-3}$	$9.4\times {10}^{-2}$	0.598	1.706	1.931	47
	1.1	$4.5\times {10}^{-6}$	$4.9\times {10}^{-4}$	$3.7\times {10}^{-3}$	1.822	1.843	1.927	0
	0.1	0	$1.6\times {10}^{-2}$	$2.8\times {10}^{-1}$	0.051	1.756	2.096	28
	0.2	0	$1.0\times {10}^{-3}$	$3.5\times {10}^{-2}$	0.102	0.814	2.108	142
	0.3	0	0	0	0.133	0.615	1.879	200
	0.4	0	0	0	0.066	0.172	0.474	200
	0.5	0	0	0	0.232	0.342	0.615	200
robot3	0.6	0	0	0	0.366	0.460	0.662	200
	0.7	0	0	0	0.640	0.765	0.933	200
	0.8	0	0	0	1.148	1.351	1.717	200
	0.9	0	$5.6\times {10}^{-7}$	$4.4\times {10}^{-6}$	1.591	1.861	3.674	34
	1	0	$8.0\times {10}^{-4}$	$2.3\times {10}^{-2}$	0.858	1.920	2.114	41
	1.1	$2.3\times {10}^{-5}$	$6.1\times {10}^{-4}$	$3.9\times {10}^{-3}$	1.998	2.023	2.119	0

. To avoid the influence of the crossover probability on the mutation factor, we again choose two different crossover probabilities to track the trajectory of task 3, which could be expressed as $CR=0.3$ and $CR=0.6$. The specific results are shown in

Table 9. Influence of crossover factor on best DE algorithm with $CR$ = 0.3, 5 DOF robot arm (robot1), 6 DOF robot arm (robot2), 7 DOF robot arm (robot3).

Name		Error			Time			Suc
Robot	F	Min	Mean	Max	Min	Mean	Max	Suc
	0.1	0	$4.2\times {10}^{-3}$	$1.9\times {10}^{-1}$	0.197	1.373	4.158	60
	0.2	0	$1.0\times {10}^{-4}$	$1.0\times {10}^{-3}$	0.529	1.510	3.768	63
	0.3	0	$4.7\times {10}^{-7}$	$3.0\times {10}^{-6}$	1.011	1.600	1.704	32
	0.4	0	$8.3\times {10}^{-7}$	$1.1\times {10}^{-5}$	1.015	1.597	1.665	5
	0.5	$1.7\times {10}^{-7}$	$1.6\times {10}^{-6}$	$3.8\times {10}^{-5}$	1.612	1.636	1.687	0
robot1	0.6	$3.1\times {10}^{-7}$	$3.2\times {10}^{-6}$	$6.6\times {10}^{-5}$	1.591	1.629	1.983	0
	0.7	$5.4\times {10}^{-7}$	$6.0\times {10}^{-6}$	$2.5\times {10}^{-5}$	1.618	1.635	1.691	0
	0.8	$9.6\times {10}^{-7}$	$9.0\times {10}^{-6}$	$1.7\times {10}^{-4}$	1.602	1.619	1.677	0
	0.9	$9.4\times {10}^{-7}$	$1.8\times {10}^{-5}$	$5.2\times {10}^{-4}$	1.592	1.609	1.674	0
	1	$3.8\times {10}^{-6}$	$2.9\times {10}^{-5}$	$3.3\times {10}^{-4}$	1.594	1.628	1.930	0
	1.1	$9.3\times {10}^{-6}$	$5.4\times {10}^{-5}$	$8.9\times {10}^{-4}$	1.590	1.616	1.691	0
	0.1	0	$4.0\times {10}^{-4}$	$1.1\times {10}^{-2}$	0.686	1.722	1.913	28
	0.2	$7.9\times {10}^{-7}$	$6.4\times {10}^{-5}$	$3.6\times {10}^{-6}$	1.748	1.765	1.905	0
	0.3	$2.3\times {10}^{-6}$	$2.4\times {10}^{-4}$	$6.4\times {10}^{-5}$	1.740	1.762	1.912	0
	0.4	$7.8\times {10}^{-6}$	$1.4\times {10}^{-4}$	$4.8\times {10}^{-4}$	1.691	1.715	1.806	0
	0.5	$1.1\times {10}^{-5}$	$3.4\times {10}^{-4}$	1.4	1.765	1.781	1.851	0
robot2	0.6	$2.0\times {10}^{-4}$	$4.6\times {10}^{-3}$	$1.7\times {10}^{-2}$	1.692	1.712	1.786	0
	0.7	$6.0\times {10}^{-4}$	$7.9\times {10}^{-3}$	$4.8\times {10}^{-2}$	1.701	1.721	1.832	0
	0.8	$2.0\times {10}^{-4}$	$1.3\times {10}^{-2}$	$7.0\times {10}^{-2}$	1.718	1.747	1.846	0
	0.9	$1.9\times {10}^{-3}$	$2.4\times {10}^{-2}$	$8.3\times {10}^{-2}$	1.725	1.747	1.818	0
	1	$1.7\times {10}^{-3}$	$2.0\times {10}^{-2}$	$8.8\times {10}^{-2}$	1.721	1.738	1.824	0
	1.1	$6.0\times {10}^{-4}$	$1.8\times {10}^{-2}$	$8.8\times {10}^{-2}$	1.721	1.742	1.823	0
	0.1	0	$9.0\times {10}^{-4}$	$2.3\times {10}^{-2}$	0.465	1.792	2.049	34
	0.2	0	$3.5\times {10}^{-5}$	$1.9\times {10}^{-3}$	0.943	1.884	2	2
	0.3	$2.2\times {10}^{-7}$	$3.6\times {10}^{-6}$	$1.6\times {10}^{-4}$	1.870	1.891	1.978	0
	0.4	$2.7\times {10}^{-7}$	$7.6\times {10}^{-6}$	$4.6\times {10}^{-4}$	1.856	1.874	1.966	0
	0.5	$1.2\times {10}^{-6}$	$1.3\times {10}^{-5}$	$2.3\times {10}^{-4}$	1.880	1.908	1.987	0
robot3	0.6	$1.8\times {10}^{-6}$	$3.6\times {10}^{-5}$	$2.4\times {10}^{-3}$	1.861	1.881	1.946	0
	0.7	$1.3\times {10}^{-5}$	$1.9\times {10}^{-4}$	$5.4\times {10}^{-3}$	1.875	1.896	2.026	0
	0.8	$1.0\times {10}^{-4}$	$1.6\times {10}^{-3}$	$1.9\times {10}^{-2}$	1.854	1.878	1.938	0
	0.9	$2.0\times {10}^{-4}$	$3.8\times {10}^{-3}$	$1.5\times {10}^{-2}$	1.849	1.876	1.958	0
	1	$7.0\times {10}^{-4}$	$7.4\times {10}^{-3}$	$5.3\times {10}^{-2}$	1.862	1.886	1.995	0
	1.1	$1.5\times {10}^{-3}$	$1.1\times {10}^{-2}$	$4.3\times {10}^{-2}$	1.843	1.866	1.988	0

and

Table 10. Influence of crossover factor on best DE algorithm with $CR$ = 0.6, 5 DOF robot arm (robot1), 6 DOF robot arm (robot2), 7 DOF robot arm (robot3).

Name		Error			Time			Suc
Robot	F	Min	Mean	Max	Min	Mean	Max	Suc
	0.1	0	$1.6\times {10}^{-2}$	$2.5\times {10}^{-1}$	0.080	1.301	1.645	40
	0.2	0	$1.0\times {10}^{-3}$	$2.5\times {10}^{-2}$	0.130	0.836	1.644	129
	0.3	0	0	0	0.192	0.476	1.336	200
	0.4	0	0	0	0.361	0.564	1.259	200
	0.5	0	0	0	0.535	0.790	1.245	200
robot1	0.6	0	$2.0\times {10}^{-9}$	$2.8\times {10}^{-7}$	0.752	1.224	1.667	198
	0.7	0	$3.4\times {10}^{-7}$	$3.6\times {10}^{-6}$	1.291	1.639	2.531	18
	0.8	0	$2.0\times {10}^{-6}$	$2.3\times {10}^{-5}$	1.595	1.620	1.727	1
	0.9	$7.5\times {10}^{-7}$	$8.1\times {10}^{-6}$	$7.4\times {10}^{-5}$	1.599	1.660	2.887	0
	1	$3.0\times {10}^{-6}$	$2.9\times {10}^{-5}$	$9.7\times {10}^{-4}$	1.624	1.651	1.718	0
	1.1	$1.1\times {10}^{-5}$	$8.1\times {10}^{-5}$	$9.8\times {10}^{-4}$	1.618	1.645	1.771	0
	0.1	0	$3.0\times {10}^{-3}$	$2.8\times {10}^{-1}$	0.105	0.914	1.823	117
	0.2	0	$8.0\times {10}^{-4}$	$4.0\times {10}^{-2}$	0.371	1.338	1.973	124
	0.3	0	$3.2\times {10}^{-5}$	$2.1\times {10}^{-3}$	0.793	1.630	1.908	74
	0.4	0	$6.2\times {10}^{-7}$	$7.9\times {10}^{-5}$	0.885	1.569	3.325	154
	0.5	0	$1.5\times {10}^{-6}$	$1.8\times {10}^{-4}$	1.260	1.768	1.924	24
robot2	0.6	$7.0\times {10}^{-7}$	$6.7\times {10}^{-6}$	$3.1\times {10}^{-4}$	1.767	1.813	2.274	0
	0.7	$2.8\times {10}^{-6}$	$4.9\times {10}^{-5}$	$2.2\times {10}^{-4}$	1.744	1.774	1.841	0
	0.8	$4.3\times {10}^{-5}$	$7.1\times {10}^{-4}$	$3.8\times {10}^{-3}$	1.763	1.820	2.437	0
	0.9	$6.1\times {10}^{-4}$	$4.6\times {10}^{-5}$	$4.5\times {10}^{-2}$	1.821	1.980	3.188	0
	1	$2.5\times {10}^{-3}$	$2.4\times {10}^{-2}$	$8.0\times {10}^{-2}$	1.823	1.893	2.589	0
	1.1	$5.2\times {10}^{-3}$	$3.2\times {10}^{-2}$	$1.1\times {10}^{-1}$	1.852	1.930	2.932	0
	0.1	0	$9.0\times {10}^{-4}$	$4.0\times {10}^{-2}$	0.121	1.295	3.028	88
	0.2	0	$3.7\times {10}^{-3}$	$1.5\times {10}^{-1}$	0.231	1.466	2.555	112
	0.3	0	$1.2\times {10}^{-5}$	$8.7\times {10}^{-4}$	0.597	1.614	3.000	139
	0.4	0	$5.0\times {10}^{-8}$	$2.1\times {10}^{-6}$	0.793	1.603	2.739	180
	0.5	0	$5.0\times {10}^{-7}$	$2.2\times {10}^{-5}$	1.168	2.069	3.114	21
robot3	0.6	0	$2.2\times {10}^{-6}$	$1.7\times {10}^{-4}$	1.860	2.151	3.676	1
	0.7	$1.3\times {10}^{-6}$	$9.6\times {10}^{-6}$	3.3	1.953	2.039	2.765	0
	0.8	$4.2\times {10}^{-6}$	$4.0\times {10}^{-5}$	$1.9\times {10}^{-4}$	1.967	2.106	3.345	0
	0.9	$1.0\times {10}^{-4}$	$4.0\times {10}^{-4}$	$6.5\times {10}^{-3}$	1.975	2.062	2.920	0
	1	$1.0\times {10}^{-4}$	$4.5\times {10}^{-3}$	$1.5\times {10}^{-2}$	1.974	2.049	2.777	0
	1.1	$9.0\times {10}^{-4}$	$1.1\times {10}^{-2}$	$3.4\times {10}^{-2}$	1.999	2.126	4.149	0

.

The results are compared for different variation factors considering a fixed $CR$ of 0.9 and an $NP$ of 50, as shown in Table 8. Among the best DE algorithms with different mutation parameters, the success rate of solving the inverse kinematics problem is between 0.3 and 0.8, and the error is close to 0. The range of the variation factor that required the shortest time for solving the inverse kinematics problem of the mobile manipulator is within [0.4–0.6], and whose mean time is less than 0.5 s. In this case, the setting range of the mutation factor in the best differential evolution algorithm is between 0.4 and 0.6, and the best setting value ranges from 0.4 to 0.5 for all mobile manipulator robots in this study.

To avoid the influence of crossover probability on the selection of mutation factors, we choose two different crossover probabilities to perform trajectory tracking on task 3 again, and the corresponding simulation results are shown in Table 9 and Table 10. By comparing the mean error in Table 8, Table 9 and Table 10, we find that the performance of the best DE algorithm with same mutation factor gradually improves as the crossover probability increases from 0.3 to 0.9.

Comparing the times in Table 8, Table 9 and Table 10, we find that the time required to reach a solution of the best DE algorithm substantially differs among the robots when the crossover probability is set at 0.9. For robot2, we find no notable difference in the mean time of the best DE algorithm when the crossover probability is set to 0.3 or 0.6, but most algorithms require more time than the previous setting.

5.3.2. Crossover Probability

To determine the best crossover probability (CR), we continuously select ten parameters within [0–1] as the CR and study the impact of the CR in solving inverse kinematics. Then, we choose task 3 as the typical trajectory to be tracked; the rest of the parameter settings remain unchanged except the variation factor, which is set to F = 0.4.

Comparing the total error in

Table 11. The influence of crossover probability on the best DE algorithm when $F=0.4$, 5 DOF robot arm (robot1), 6 DOF robot arm (robot2), and 7 DOF robot arm (robot3).

Name		Error			Time			Suc
Robot	DE	Min	Mean	Max	Min	Mean	Max	Suc
	0.1	$1.7\times {10}^{-7}$	$8.1\times {10}^{-6}$	$1.4\times {10}^{-4}$	1.573	1.595	1.654	0
	0.2	$2.5\times {10}^{-7}$	$2.1\times {10}^{-6}$	$4.1\times {10}^{-5}$	1.592	1.617	1.668	0
	0.3	0	$8.8\times {10}^{-7}$	$2.2\times {10}^{-5}$	0.887	1.614	1.673	4
	0.4	0	$2.2\times {10}^{-7}$	$1.8\times {10}^{-6}$	0.762	1.526	1.667	61
	0.5	0	$3.0\times {10}^{-9}$	$6.0\times {10}^{-7}$	0.547	1.048	1.660	199
robot1	0.6	0	0	0	0.329	0.549	1.066	200
	0.7	0	0	0	0.207	0.333	0.683	200
	0.8	0	0	0	0.137	0.215	0.469	200
	0.9	0	0	0	0.137	0.215	0.469	200
	1	0	$1.2\times {10}^{-2}$	$1.7\times {10}^{-1}$	0.062	1.304	1.644	40
	0.1	$4.0\times {10}^{-4}$	$1.0\times {10}^{-3}$	$5.6\times {10}^{-2}$	1.733	1.763	2.480	0
	0.2	$2.6\times {10}^{-4}$	$5.0\times {10}^{-3}$	3.2	1.733	1.763	2.480	0
	0.3	$1.0\times {10}^{-5}$	$4.4\times {10}^{-3}$	$3.0\times {10}^{-2}$	1.737	1.765	1.819	0
	0.4	$1.2\times {10}^{-6}$	$1.0\times {10}^{-5}$	4.6	1.715	1.743	1.796	0
	0.5	$1.6\times {10}^{-7}$	$1.1\times {10}^{-5}$	1.3	1.726	1.746	1.820	0
robot2	0.6	0	$5.7\times {10}^{-7}$	$5.8\times {10}^{-5}$	0.859	1.425	1.774	169
	0.7	0	$3.6\times {10}^{-7}$	$2.5\times {10}^{-5}$	0.409	0.865	1.788	192
	0.8	0	$6.1\times {10}^{-8}$	$1.2\times {10}^{-5}$	0.253	0.683	1.774	199
	0.9	0	$4.2\times {10}^{-7}$	$8.4\times {10}^{-5}$	0.166	0.518	1.751	199
	1	0	$7.7\times {10}^{-3}$	$8.4\times {10}^{-2}$	0.008	1.398	1.814	47
	0.1	$1.0\times {10}^{-4}$	$4.0\times {10}^{-3}$	$2.3\times {10}^{-2}$	1.900	1.929	1.998	0
	0.2	$3.5\times {10}^{-6}$	$1.4\times {10}^{-4}$	$1.5\times {10}^{-2}$	1.891	1.918	1.977	0
	0.3	$6.8\times {10}^{-7}$	$9.8\times {10}^{-6}$	$1.0\times {10}^{-3}$	1.870	1.905	1.966	0
	0.4	$2.0\times {10}^{-7}$	$2.7\times {10}^{-6}$	$1.0\times {10}^{-4}$	1.900	1.924	1.990	0
	0.5	0	$1.1\times {10}^{-6}$	1.0	1.536	1.905	1.973	7
robot3	0.6	0	$8.5\times {10}^{-8}$	$1.4\times {10}^{-5}$	0.810	1.415	1.965	188
	0.7	0	$1.0\times {10}^{-8}$	$2.1\times {10}^{-6}$	0.449	0.753	1.986	199
	0.8	0	0	0	0.320	0.595	1.601	200
	0.9	0	0	0	0.200	0.498	1.765	200
	1	0	$1.0\times {10}^{-2}$	$1.4\times {10}^{-1}$	0.089	1.484	1.974	55

, The results show that the best DE algorithm with same variation factor improved as the crossover probability increases from 0.6 to 0.9. Outside this range, the success rate of the IK solution of these mobile manipulator robots substantially reduce, and the trajectory tracking error is relatively large. By comparing the mean times in Table 11, we find that the solution mean time and maximum time of the best DE algorithm are markedly different for all robots when the $CR$ is set to (0.9–1.0). However, when the $CR$ is set to 0.1 and 0.5, the time of the best DE algorithm is the longest and does not differ much. The solution time of the best DE algorithm gradually decreases as the crossover factor changed from 0.7 to 0.9; the crossover probability of the best differential evolution algorithm is best in the range of (0.7–0.9).

5.3.3. Population Size

To determine the best population size (NP), we continuously select eleven parameters from 20 to 70 as the population size to study the impact of NP on solving the IK problem. We also choose task 3 as the typical trajectory to be tracked by the end effector, F is set to 0.4, $CR$ is set to 0.9, and the rest of the parameter settings remain unchanged. The total error and time used to solve the problem with different variation factors are shown in

Table 12. The influence of population size on the best DE algorithm with $F=0.4,CR=0.8$. Total error and time for the mobile manipulator robot with 5 DOF arm (robot1), 6 DOF arm (robot2), and 7 DOF arm (robot3).

Name		Error			Time			Suc
Robot	NP	Min	Mean	Max	Min	Mean	Max	Suc
	20	0	$6.0\times {10}^{-4}$	$2.1\times {10}^{-2}$	0.048	0.254	0.655	183
	25	0	$1.1\times {10}^{-8}$	$2.2\times {10}^{-6}$	0.062	0.255	0.810	199
	30	0	0	0	0.073	0.225	0.553	200
	35	0	0	0	0.074	0.209	0.776	200
	40	0	0	0	0.088	0.200	0.573	200
robot1	45	0	0	0	0.090	0.175	0.589	200
	50	0	0	0	0.104	0.185	0.469	200
	55	0	0	0	0.102	0.158	0.409	200
	60	0	0	0	0.102	0.163	0.282	200
	65	0	0	0	0.127	0.172	0.363	200
	70	0	0	0	0.135	0.175	0.319	200
	20	0	0	0	0.055	0.214	0.631	200
	25	0	0	0	0.080	0.281	0.867	200
	30	0	0	0	0.081	0.302	0.957	200
	35	0	$8.0\times {10}^{-9}$	$1.6\times {10}^{-6}$	0.132	0.423	1.258	199
	40	0	$4.9\times {10}^{-8}$	$9.8\times {10}^{-6}$	0.147	0.472	1.392	199
robot2	45	0	0	0	0.168	0.510	1.330	200
	50	0	0	0	0.207	0.570	1.659	200
	55	0	0	0	0.201	0.509	1.705	200
	60	0	0	0	0.193	0.468	1.215	200
	65	0	0	0	0.211	0.497	1.510	200
	70	0	0	0	0.212	0.436	1.840	200
	20	0	$1.3\times {10}^{-3}$	$8.4\times {10}^{-2}$	0.060	0.301	0.799	186
	25	0	$3.0\times {10}^{-4}$	$6.1\times {10}^{-2}$	0.109	0.421	0.981	194
	30	0	$1.9\times {10}^{-8}$	$3.3\times {10}^{-6}$	0.146	0.491	1.167	197
	35	0	$2.6\times {10}^{-8}$	$5.2\times {10}^{-6}$	0.157	0.574	1.392	199
	40	0	0	0	0.158	0.557	1.513	200
robot3	45	0	0	0	0.186	0.528	1.586	200
	50	0	0	0	0.197	0.580	1.859	200
	55	0	0	0	0.197	0.509	1.429	200
	60	0	0	0	0.204	0.464	1.438	200
	65	0	0	0	0.213	0.416	0.929	200
	70	0	0	0	0.240	0.413	1.093	200

.

A comparison of the total error in Table 12 shows that the DE algorithm performs the best when the population size is more than 25, and the trajectory tracking error is relatively small. Comparing the times in Table 12 shows that the average time required by the best DE algorithm first increases to a plateau and then gradually decreases for robot1 and robot2 as the population size increases from 20 to 70. For robot1, the average time requires to reaction a solution of the best DE algorithm does not notably change. However, the average time of the best DE algorithm is less than 0.5 s for all robots when the population size is more than 60. To ensure diversity, we set the optimal population size of the best DE algorithm to (60–70) for these mobile manipulator robots.

6. Conclusions

In this study, we compare the performance of various DE algorithms when dealing with the IK problem of mobile manipulator robots. We investigate the specific optimization techniques of various DE algorithms to guide future improvements in the DE algorithm. As the most important problem, IK becomes increasingly difficult with an increase in the DOFs. Therefore, we define the IK of a mobile manipulator as a variety of global optimal problem functions according to different task requirements. To determine the best DE algorithm for solving the problem, various DE algorithms are used to solve the IK problem of mobile manipulators with different DOFs. We further improve the performance of the best DE algorithm based on the specific influence of the different parameters on the DE algorithm.

In the future, we aim to design a new DE algorithm with better performance to solve the IK problem. We will use the DE algorithm to achieve path planning and trajectory tracking for mobile manipulator robots with physical limitations in complex environments.