[mlir] Add EqualOp and NotEqualOp to complex dialect.

[akuegel]

Summary

For complex numbers, only equal and not equal comparisons are defined.
So this patch adds those comparisons as two different ops, instead of going the
way with one op and an attribute.

[pifon2a]

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

174

nit: can we call them EqualOp and NotEqualOp like in TOSA and TF dialects?

[akuegel]

Rename to EqualOp and NotEqualOp.

[akuegel]

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

174

Sure, makes sense :)
Done.

[pifon2a]

https://github.com/llvm/llvm-project/commit/a28fe17d7315f72b802b4ac4b4bc1603ffe7a23b

mlir/include/mlir/Dialect/Complex/IR/ComplexOps.td

def ImOp : Complex_Op<"im",
   let arguments = (ins Complex<AnyFloat>:$complex);
   let results = (outs AnyFloat:$imaginary);
 
   let assemblyFormat = "$complex attr-dict `:` type($complex)";
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// EqualOp
+//===----------------------------------------------------------------------===//
+
+def EqualOp : Complex_Op<"eq",
+    [NoSideEffect, AllTypesMatch<["lhs", "rhs"]>]> {
+  let summary = "computes whether two complex values are equal";
+  let description = [{
+    The `eq` op takes two complex numbers and returns whether they are equal.
+
+    Example:
+
+    ```mlir
+    %a = complex.eq %b, %c : complex<f32>
+    ```
+  }];
+
+  let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
+  let results = (outs I1:$result);
+
+  let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($lhs)";
+}
+
+//===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 def MulOp : ComplexArithmeticOp<"mul"> {
   let summary = "complex multiplication";
   let description = [{
     The `mul` operation takes two complex numbers and returns their product:
 
     ```mlir
     %a = complex.mul %b, %c : complex<f32>
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
+// NotEqualOp
+//===----------------------------------------------------------------------===//
+
+def NotEqualOp : Complex_Op<"neq",
+    [NoSideEffect, AllTypesMatch<["lhs", "rhs"]>]> {
+  let summary = "computes whether two complex values are not equal";
+  let description = [{
+    The `neq` op takes two complex numbers and returns whether they are not
+    equal.
+
+    Example:
+
+    ```mlir
+    %a = complex.neq %b, %c : complex<f32>
+    ```
+  }];
+
+  let arguments = (ins Complex<AnyFloat>:$lhs, Complex<AnyFloat>:$rhs);
+  let results = (outs I1:$result);
+
+  let assemblyFormat = "$lhs `,` $rhs  attr-dict `:` type($lhs)";
+}
+
+//===----------------------------------------------------------------------===//
 // ReOp
 //===----------------------------------------------------------------------===//
 
 def ReOp : Complex_Op<"re",
     [NoSideEffect,
      TypesMatchWith<"complex element type matches result type",
                     "complex", "real",
                     "$_self.cast<ComplexType>().getElementType()">]> {

mlir/lib/Dialect/Complex/IR/ComplexOps.cpp

 //===- ComplexOps.cpp - MLIR Complex Operations ---------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Complex/IR/Complex.h"
+#include "mlir/IR/Builders.h"
 
 using namespace mlir;
 using namespace mlir::complex;
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 

mlir/test/Dialect/Complex/ops.mlir

func @ops(%f: f32) {
   %abs = complex.abs %complex : complex<f32>
 
   // CHECK: complex.add %[[C]], %[[C]] : complex<f32>
   %sum = complex.add %complex, %complex : complex<f32>
 
   // CHECK: complex.div %[[C]], %[[C]] : complex<f32>
   %div = complex.div %complex, %complex : complex<f32>
 
+  // CHECK: complex.eq %[[C]], %[[C]] : complex<f32>
+  %eq = complex.eq %complex, %complex : complex<f32>
+
+  // CHECK: complex.neq %[[C]], %[[C]] : complex<f32>
+  %neq = complex.neq %complex, %complex : complex<f32>
+
   // CHECK: complex.mul %[[C]], %[[C]] : complex<f32>
   %prod = complex.mul %complex, %complex : complex<f32>
 
   // CHECK: complex.sub %[[C]], %[[C]] : complex<f32>
   %diff = complex.sub %complex, %complex : complex<f32>
   return
 }