Fixes #811. Since NaN and infinity are closely related concepts, I'm introducing both logical unary operators together for completeness.

partial interface MLGraphBuilder
{
    ...
+   MLOperand isNaN(MLOperand a, optional MLOperatorOptions options = {})
+   MLOperand isInfinite(MLOperand a, optional MLOperatorOptions options = {})
    ...
};

Mappings to backend functions:

Is not-a-number:

• numpy.isnan
• tf.math.is_nan
• torch.isnan
• onnx.ai.IsNaN
• DML_OPERATOR_ELEMENT_WISE_IS_NAN
• mil.ops.defs.iOS15.elementwise_binary.not_equal(a, a)

Is infinite:

• numpy.isinf
• tfm.optimization.math.isinf
• torch.isinf
• onnx.ai.IsInf
• DML_OPERATOR_ELEMENT_WISE_IS_INFINITY
• mil.ops.defs.iOS15.elementwise_unary.abs(..) &&
  mil.ops.defs.iOS15.elementwise_binary.equal(.., Infinity)

Possible question answers:

• Why name it "isInfinite" rather than "isinf" like Python API's? This isn't Python, it's closer kin to Javascript's isFinite function and Infinite constant, and general API naming guidelines favor whole words for readability.
• Why not support specific tests for positive infinity or negative infinity like ONNX? I'm not opposed to it, but I'm unsure the use case, most backends don't support it, and one could easily clamp the values before calling isInfinite to emulate it.
• Do we really need these functions? No - technically they can be emulated via existing logical operators, but backends may have more optimized forms of them, and their existence leads to better discoverability. One compromise would be to instead document a decomposition in the specification (similar to flatten and unsqueeze) in the Operator Emulation section.

Here are some example emulations:

function isNaN(value: Number): Boolean
{
    return value != value;
    // graphBuilder.notEqual(value, value)
    // low level equivalent: return value.reinterpretAs(uint32) & 0x7FFFFFFF) > 0x7F800000;
}

function isNotNaN(value: Number): Boolean
{
    return value == value;
    // graphBuilder.equal(value, value)
}

function isInfinite(value: Number): Boolean
{
    return abs(value) == Infinity;
}

function isNaNOrInfinity(value: Number): Boolean
{
    return (value * 0) != 0;
    // graphBuilder.notEqual(graphBuilder.mul(x, zeroTensor), zeroTensor)
}

function isNotNaNOrInfinity(value: Number): Boolean
{
    return (value * 0) == 0;
    // graphBuilder.equal(graphBuilder.mul(x, zeroTensor), zeroTensor)
}

Preview | Diff