org.hamcrest.core Tests whether the value is an instance of a class. IsInstanceOf(Class<?>) - Constructor for class org.hamcrest.core.IsInstanceOf Creates a new instance of IsInstanceOf IsNot<T> - Class in org.hamcrest.core Calculates the logical negation of a matcher. IsNot(Matcher<T>) - Constructor for class org.hamcrest.core.IsNot IsNull<T> - Class in org.hamcrest.core Is the value null? IsNull() - Constructor for class org.hamcrest.core.IsNull IsSame<T> - Class in org.hamcrest.core Is the value...

    }
  }];

  let hasOptions = 1;
}

def TFL_NegOp: TFL_Op<"neg", [
    Pure,
    TF_SameOperandsAndResultTypeResolveRef]> {
  let summary = "Negation operator";

  let description = [{
    Computes element-wise negation of input
  }];

  let arguments = (ins TFL_TensorOf<[F32, I32, I64]>:$x);

  let results = (outs TFL_TensorOf<[F32, I32, I64]>:$y);

  let hasOptions = 0b1;

		{name: "PXOR", argLength: 2, reg: fp21, asm: "PXOR", commutative: true, resultInArg0: true}, // exclusive or, applied to X regs (for float negation).
		{name: "POR", argLength: 2, reg: fp21, asm: "POR", commutative: true, resultInArg0: true},   // inclusive or, applied to X regs (for float min/max).

<p>
For integer operands, the unary operators
<code>+</code>, <code>-</code>, and <code>^</code> are defined as
follows:
</p>

<pre class="grammar">
+x                          is 0 + x
-x    negation              is 0 - x
^x    bitwise complement    is m ^ x  with m = "all bits set to 1" for unsigned x
                                      and  m = -1 for signed x
</pre>

(Sub16 x (Const16 <t> [c])) && x.Op != OpConst16 => (Add16 (Const16 <t> [-c]) x)
(Sub8  x (Const8  <t> [c])) && x.Op != OpConst8  => (Add8  (Const8  <t> [-c]) x)

// fold negation into comparison operators
(Not (Eq(64|32|16|8|B|Ptr|64F|32F) x y)) => (Neq(64|32|16|8|B|Ptr|64F|32F) x y)
(Not (Neq(64|32|16|8|B|Ptr|64F|32F) x y)) => (Eq(64|32|16|8|B|Ptr|64F|32F) x y)

// This ensures that code making use of v2 features continues to compile
// when, say, GOAMD64=v4 is introduced.
// Code handling the absence of a particular feature level
// should use a negation:
//
//	//go:build !amd64.v2
//
// To keep a file from being considered for any build:
//
//	//go:build ignore
//
// (Any other unsatisfied word will work as well, but "ignore" is conventional.)