Function EqualHelper

tensorflow/compiler/xla/literal_comparison.cc:678–769

constexpr std::array<float, 5> NearComparator<NativeT>::kErrorBucketBounds;

Status EqualHelper(const LiteralSlice& expected, const LiteralSlice& actual,
                   const ShapeIndex& shape_index,
                   const MiscompareCallback& miscompare_callback) {
  TF_RETURN_IF_ERROR(EqualShapes(expected.shape(), actual.shape()));

  Status result;
  if (expected.shape().IsTuple()) {
    ShapeIndex next_index = shape_index;
    for (int i = 0; i < ShapeUtil::TupleElementCount(expected.shape()); ++i) {
      next_index.push_back(i);
      Status tuple_result =
          EqualHelper(LiteralSlice(expected, {i}), LiteralSlice(actual, {i}),
                      next_index, miscompare_callback);
      if (miscompare_callback) {
        result.Update(tuple_result);
      } else {
        TF_RETURN_IF_ERROR(tuple_result);
      }
      next_index.pop_back();
    }
  } else {
    std::vector<int64> multi_index(expected.shape().dimensions_size(), 0);
    auto index = absl::MakeSpan(multi_index);

    Shape unequal_shape = ShapeUtil::MakeShape(PrimitiveType::PRED,
                                               expected.shape().dimensions());
    Literal miscompared(unequal_shape);
    Literal* miscompared_ptr =
        (miscompare_callback == nullptr ? nullptr : &miscompared);

    switch (expected.shape().element_type()) {
      case PRED:
        result = Equal<bool>(expected, actual, index, 0, miscompared_ptr);
        break;
      case S8:
        result = Equal<int8>(expected, actual, index, 0, miscompared_ptr);
        break;
      case S16:
        result = Equal<int16>(expected, actual, index, 0, miscompared_ptr);
        break;
      case S32:
        result = Equal<int32>(expected, actual, index, 0, miscompared_ptr);
        break;
      case S64:
        result = Equal<int64>(expected, actual, index, 0, miscompared_ptr);
        break;
      case U8:
        result = Equal<uint8>(expected, actual, index, 0, miscompared_ptr);
        break;
      case U16:
        result = Equal<uint16>(expected, actual, index, 0, miscompared_ptr);
        break;
      case U32:
        result = Equal<uint32>(expected, actual, index, 0, miscompared_ptr);
        break;
      case U64:
        result = Equal<uint64>(expected, actual, index, 0, miscompared_ptr);
        break;