docs: static boolean polylineRelatePoint_(Polyline polyline_a, Point point_b,
  			double tolerance, String scl, ProgressTracker progress_tracker) {
          RelationalOperationsMatrix relOps = new RelationalOperationsMatrix();
          relOps.resetMatrix_();
          relOps.setPredicates_(scl);
          relOps.setLinePointPredicates_();
  
          Envelope2D env_a = new Envelope2D();
          polyline_a.queryEnvelope2D(env_a);
          Point2D pt_b = point_b.getXY();
  
          boolean bRelationKnown = false;
          boolean b_disjoint = RelationalOperations.pointDisjointEnvelope_(pt_b, env_a, tolerance, progress_tracker);
  
          if (b_disjoint)
          {
              relOps.linePointDisjointPredicates_(polyline_a);
              bRelationKnown = true;
          }
  
          if (!bRelationKnown)
          {
              MultiPoint boundary_a = null;
              boolean b_boundary_contains_point_known = false;
              boolean b_boundary_contains_point = false;
  
              if (relOps.m_perform_predicates[MatrixPredicate.InteriorInterior] || relOps.m_perform_predicates[MatrixPredicate.ExteriorInterior])
              {
                  boolean b_intersects = RelationalOperations.linearPathIntersectsPoint_(polyline_a, pt_b, tolerance);
  
                  if (b_intersects)
                  {
                      if (relOps.m_perform_predicates[MatrixPredicate.InteriorInterior])
                      {
                          boundary_a = (MultiPoint)Boundary.calculate(polyline_a, progress_tracker);
                          b_boundary_contains_point = !RelationalOperations.multiPointDisjointPointImpl_(boundary_a, pt_b, tolerance, progress_tracker);
                          b_boundary_contains_point_known = true;
  
                          if (b_boundary_contains_point)
                              relOps.m_matrix[MatrixPredicate.InteriorInterior] = -1;
                          else
                              relOps.m_matrix[MatrixPredicate.InteriorInterior] = 0;
                      }
  
                      relOps.m_matrix[MatrixPredicate.ExteriorInterior] = -1;
                  }
                  else
                  {
                      relOps.m_matrix[MatrixPredicate.InteriorInterior] = -1;
                      relOps.m_matrix[MatrixPredicate.ExteriorInterior] = 0;
                  }
              }
  
              if (relOps.m_perform_predicates[MatrixPredicate.BoundaryInterior])
              {
                  if (boundary_a != null && boundary_a.isEmpty())
                  {
                      relOps.m_matrix[MatrixPredicate.BoundaryInterior] = -1;
                  }
                  else
                  {
                      if (!b_boundary_contains_point_known)
                      {
                          if (boundary_a == null)
                              boundary_a = (MultiPoint)Boundary.calculate(polyline_a, progress_tracker);
  
                          b_boundary_contains_point = !RelationalOperations.multiPointDisjointPointImpl_(boundary_a, pt_b, tolerance, progress_tracker);
                          b_boundary_contains_point_known = true;
                      }
  
                      relOps.m_matrix[MatrixPredicate.BoundaryInterior] = (b_boundary_contains_point ? 0 : -1);
                  }
              }
  
              if (relOps.m_perform_predicates[MatrixPredicate.BoundaryExterior])
              {
                  if (boundary_a != null && boundary_a.isEmpty())
                  {
                      relOps.m_matrix[MatrixPredicate.BoundaryExterior] = -1;
                  }
                  else
                  {
                      if (b_boundary_contains_point_known && !b_boundary_contains_point)
                      {
                          relOps.m_matrix[MatrixPredicate.BoundaryExterior] = 0;
                      }
                      else
                      {
                          if (boundary_a == null)
                              boundary_a = (MultiPoint)Boundary.calculate(polyline_a, progress_tracker);
  
                          boolean b_boundary_equals_point = RelationalOperations.multiPointEqualsPoint_(boundary_a, point_b, tolerance, progress_tracker);
                          relOps.m_matrix[MatrixPredicate.BoundaryExterior] = (b_boundary_equals_point ? -1 : 0);
                      }
                  }
              }
  
              if (relOps.m_perform_predicates[MatrixPredicate.InteriorExterior])
              {
                  boolean b_has_length = polyline_a.calculateLength2D() != 0;
  
                  if (b_has_length)
                  {
                      relOps.m_matrix[MatrixPredicate.InteriorExterior] = 1;
                  }
                  else
                  {
                      // all points are interior
                      MultiPoint interior_a = new MultiPoint(polyline_a.getDescription());
                      interior_a.add(polyline_a, 0, polyline_a.getPointCount());
                      boolean b_interior_equals_point = RelationalOperations.multiPointEqualsPoint_(interior_a, point_b, tolerance, progress_tracker);
                      relOps.m_matrix[MatrixPredicate.InteriorExterior] = (b_interior_equals_point ? -1 : 0);
                  }
              }
          }
  
          boolean bRelation = relationCompare_(relOps.m_matrix, relOps.m_scl);
          return bRelation;
  	}