_moveNode(m, dE_dx, dE_dy) {
    const nodesArray = this.body.nodeIndices;
    const nodes = this.body.nodes;
    let d2E_dx2 = 0;
    let d2E_dxdy = 0;
    let d2E_dy2 = 0;

    const x_m = nodes[m].x;
    const y_m = nodes[m].y;
    const km = this.K_matrix[m];
    const lm = this.L_matrix[m];

    for (let iIdx = 0; iIdx < nodesArray.length; iIdx++) {
      const i = nodesArray[iIdx];
      if (i !== m) {
        const x_i = nodes[i].x;
        const y_i = nodes[i].y;
        const kmat = km[i];
        const lmat = lm[i];
        const denominator = 1.0 / ((x_m - x_i) ** 2 + (y_m - y_i) ** 2) ** 1.5;
        d2E_dx2 += kmat * (1 - lmat * (y_m - y_i) ** 2 * denominator);
        d2E_dxdy += kmat * (lmat * (x_m - x_i) * (y_m - y_i) * denominator);
        d2E_dy2 += kmat * (1 - lmat * (x_m - x_i) ** 2 * denominator);
      }
    }
    // make the variable names easier to make the solving of the linear system easier to read
    const A = d2E_dx2,
      B = d2E_dxdy,
      C = dE_dx,
      D = d2E_dy2,
      E = dE_dy;

    // solve the linear system for dx and dy
    const dy = (C / A + E / B) / (B / A - D / B);
    const dx = -(B * dy + C) / A;

    // move the node
    nodes[m].x += dx;
    nodes[m].y += dy;

    // Recalculate E_matrix (should be incremental)
    this._updateE_matrix(m);
  }
move the node based on it's energy
the dx and dy are calculated from the linear system proposed by Kamada and Kawai
@param {number} m
@param {number} dE_dx
@param {number} dE_dy
@private