//===----------------------------------------------------------------------===//

/// Converts a TF::SoftsignOp to HLO.
/// Softsign(features) = features / (1 + abs(features))
def : Pat<(TF_SoftsignOp AnyTensor:$input),
          (MHLO_DivOp
            $input,
            (MHLO_AddOp (MHLO_ConstantLike<"1"> $input), (MHLO_AbsOp $input))
          )
         >;

/// Converts a TF::SoftsignGradOp to HLO.

	// Extender will always return NodeNameToMetaVictims.
	// So let's convert it to NodeNameToVictims by using <nodeInfos>.
	newNodeNameToVictims, err := h.convertToVictims(result.NodeNameToMetaVictims, nodeInfos)
	if err != nil {
		return nil, err
	}
	// Do not override <nodeNameToVictims>.
	return newNodeNameToVictims, nil
}

// convertToVictims converts "nodeNameToMetaVictims" from object identifiers,

// convlit1 converts an untyped expression n to type t. If n already
// has a type, convlit1 has no effect.
//
// For explicit conversions, t must be non-nil, and integer-to-string
// conversions are allowed.
//
// For implicit conversions (e.g., assignments), t may be nil; if so,
// n is converted to its default type.
//

	jsonSchema *apiextensions.JSONSchemaProps
	// converter converts a JSONSchemaProps to CELTypeInfo.
	// Tests that check how many conversions are performed during CRD validation wrap DefaultConverter
	// with a converter that counts how many conversion operations.
	converter converter

	// MaxCardinality represents a limit to the number of data elements that can exist for the current

			}

		default:
			allErrs = append(allErrs, field.Invalid(fldPath, "", err.Error()))
		}
	}
	return allErrs
}

// ConvertJSONSchemaProps converts the schema from apiextensions.JSONSchemaPropos to go-openapi/spec.Schema.
func ConvertJSONSchemaProps(in *apiextensions.JSONSchemaProps, out *spec.Schema) error {
	return ConvertJSONSchemaPropsWithPostProcess(in, out, nil)
}

  let assemblyFormat = "operands attr-dict";
}

def PredicateOp : TensorflowMlrt_Op<"predicate", [Pure]> {
  let summary = "Converts a fallback tensor to a bool";

  let description = [{
    Note: this kernel is used for CPU tensors.

    Converts a fallback tensor to a bool with the following rules:

    - For 0D tensors, truthiness is determined by comparing against a "zero"

  // CHECK-NEXT: "tfl.custom"(%0, %2) <{custom_code = "FlexAssignVariableOp"
  // CHECK-NEXT: %3 = "tfl.custom"(%0) <{custom_code = "FlexReadVariableOp"
  func.return %3 : tensor<1x10xf32>
}

// -----

// Converts tfl.broadcast_to to tfl.reshape if input and output have the same
// number of elements.
// CHECK-LABEL: broadcast_to_to_reshape

				return nil, nil, nil, fmt.Errorf("failed to convert extension config struct %+v to Wasm Network filter", typedStruct)
			}
		} else if typedStruct.TypeUrl == model.WasmNetworkFilterType {
			wasmNetwork = true
			if err := conversion.StructToMessage(typedStruct.Value, wasmNetworkFilterConfig); err != nil {
				return nil, nil, nil, fmt.Errorf("failed to convert extension config struct %+v to Wasm HTTP filter", typedStruct)
			}

  ) -> np.ndarray:
    """Quantizes and dequantizes hist_mids using quant_min and quant_max.

    Quantization converts the range of numbers from [quant_min, quant_max] to
    [0, 2^num_bits - 1]. Values less than quant_min are converted to 0, and
    values greater than quant_max are converted to 2^num_bits - 1.

    The histogram represents the distribution of the data, and our goal is to

  ElementsAttr convert(Attribute real_value);

 private:
  // Quantize an DenseFPElementsAttr by the quantization parameters.
  DenseElementsAttr convert(DenseFPElementsAttr attr);

  // Get a uniform converter for the index-th chunk along the quantizationDim.
  // All the elements in this chunk is quantized by the returned converter.