createInitialSimplex () {
    const vertices = this.vertices
    const [min, max] = this.computeExtremes()
    let v2, v3
    let i, j

    // Find the two vertices with the greatest 1d separation
    // (max.x - min.x)
    // (max.y - min.y)
    // (max.z - min.z)
    let maxDistance = 0
    let indexMax = 0
    for (i = 0; i < 3; i += 1) {
      const distance = max[i].point[i] - min[i].point[i]
      if (distance > maxDistance) {
        maxDistance = distance
        indexMax = i
      }
    }
    const v0 = min[indexMax]
    const v1 = max[indexMax]

    // the next vertex is the one farthest to the line formed by `v0` and `v1`
    maxDistance = 0
    for (i = 0; i < this.vertices.length; i += 1) {
      const vertex = this.vertices[i]
      if (vertex !== v0 && vertex !== v1) {
        const distance = pointLineDistance(
          vertex.point, v0.point, v1.point
        )
        if (distance > maxDistance) {
          maxDistance = distance
          v2 = vertex
        }
      }
    }

    // the next vertes is the one farthest to the plane `v0`, `v1`, `v2`
    // normalize((v2 - v1) x (v0 - v1))
    const normal = getPlaneNormal([], v0.point, v1.point, v2.point)
    // distance from the origin to the plane
    const distPO = dot(v0.point, normal)
    maxDistance = -1
    for (i = 0; i < this.vertices.length; i += 1) {
      const vertex = this.vertices[i]
      if (vertex !== v0 && vertex !== v1 && vertex !== v2) {
        const distance = Math.abs(dot(normal, vertex.point) - distPO)
        if (distance > maxDistance) {
          maxDistance = distance
          v3 = vertex
        }
      }
    }

    // initial simplex
    // Taken from http://everything2.com/title/How+to+paint+a+tetrahedron
    //
    //                              v2
    //                             ,|,
    //                           ,7``\'VA,
    //                         ,7`   |, `'VA,
    //                       ,7`     `\    `'VA,
    //                     ,7`        |,      `'VA,
    //                   ,7`          `\         `'VA,
    //                 ,7`             |,           `'VA,
    //               ,7`               `\       ,..ooOOTK` v3
    //             ,7`                  |,.ooOOT''`    AV
    //           ,7`            ,..ooOOT`\`           /7
    //         ,7`      ,..ooOOT''`      |,          AV
    //        ,T,..ooOOT''`              `\         /7
    //     v0 `'TTs.,                     |,       AV
    //            `'TTs.,                 `\      /7
    //                 `'TTs.,             |,    AV
    //                      `'TTs.,        `\   /7
    //                           `'TTs.,    |, AV
    //                                `'TTs.,\/7
    //                                     `'T`
    //                                       v1
    //
    const faces = []
    if (dot(v3.point, normal) - distPO < 0) {
      // the face is not able to see the point so `planeNormal`
      // is pointing outside the tetrahedron
      faces.push(
        Face.createTriangle(v0, v1, v2),
        Face.createTriangle(v3, v1, v0),
        Face.createTriangle(v3, v2, v1),
        Face.createTriangle(v3, v0, v2)
      )

      // set the opposite edge
      for (i = 0; i < 3; i += 1) {
        const j = (i + 1) % 3
        // join face[i] i > 0, with the first face
        faces[i + 1].getEdge(2).setOpposite(faces[0].getEdge(j))
        // join face[i] with face[i + 1], 1 <= i <= 3
        faces[i + 1].getEdge(1).setOpposite(faces[j + 1].getEdge(0))
      }
    } else {
      // the face is able to see the point so `planeNormal`
      // is pointing inside the tetrahedron
      faces.push(
        Face.createTriangle(v0, v2, v1),
        Face.createTriangle(v3, v0, v1),
        Face.createTriangle(v3, v1, v2),
        Face.createTriangle(v3, v2, v0)
      )

      // set the opposite edge
      for (i = 0; i < 3; i += 1) {
        const j = (i + 1) % 3
        // join face[i] i > 0, with the first face
        faces[i + 1].getEdge(2).setOpposite(faces[0].getEdge((3 - i) % 3))
        // join face[i] with face[i + 1]
        faces[i + 1].getEdge(0).setOpposite(faces[j + 1].getEdge(1))
      }
    }

    // the initial hull is the tetrahedron
    for (i = 0; i < 4; i += 1) {
      this.faces.push(faces[i])
    }

    // initial assignment of vertices to the faces of the tetrahedron
    for (i = 0; i < vertices.length; i += 1) {
      const vertex = vertices[i]
      if (vertex !== v0 && vertex !== v1 && vertex !== v2 && vertex !== v3) {
        maxDistance = this.tolerance
        let maxFace
        for (j = 0; j < 4; j += 1) {
          const distance = faces[j].distanceToPlane(vertex.point)
          if (distance > maxDistance) {
            maxDistance = distance
            maxFace = faces[j]
          }
        }

        if (maxFace) {
          this.addVertexToFace(vertex, maxFace)
        }
      }
    }
  }
Compues the initial tetrahedron assigning to its faces all the points that
are candidates to form part of the hull