// RUN: tf-opt %s -split-input-file -tfl-reduce-type-precision -verify-diagnostics

func.func @testI8ToI4WithinRange() -> (tensor<4xi8>) {
  %0 = arith.constant dense<[-8, 0, 1, 7]> : tensor<4xi8>
  // expected-error@+1 {{type of return operand 0 ('tensor<4xi4>') doesn't match function result type ('tensor<4xi8>')}}
  func.return %0 : tensor<4xi8>
}

func.func @testI8ToI4NotWithinRange() -> tensor<4xi8> {
  %0 = arith.constant dense<[-10, 2, 3, 8]> : tensor<4xi8>

{
  "apiVersion": "v1",
  "kind": "Pod",
  "metadata": {
    "name": "pod-with-precision"
  },
  "spec": {
    "activeDeadlineSeconds": 2147483647,
    "containers": [
      {
        "name": "kubernetes-pause",
        "image": "registry.k8s.io/pause:3.10"
      }
    ],
    "restartPolicy": "Never",
    "securityContext": {
      "supplementalGroups": [
        0,
        1000030003,
        2147483647
      ]

ymqytw <******@****.***> 1510695623 -0800

Jefftree <******@****.***> 1694810813 -0400

		threeOnce.v = NewFloat(3.0)
	})
	return threeOnce.v
}

// Sqrt sets z to the rounded square root of x, and returns it.
//
// If z's precision is 0, it is changed to x's precision before the
// operation. Rounding is performed according to z's precision and
// rounding mode, but z's accuracy is not computed. Specifically, the
// result of z.Acc() is undefined.
//

     *
     * If `isCurrentTimestampHighPrecision` is in `millisecond` precision, then all file timestamps will have `millisecond` precision
     * since we check all Java APIs that can return a high or a low precision, and we choose the one with the lowest precision.
     *
     * In case `isCurrentTimestampHighPrecision` is in the `second` precision, then we check also the provided timestamp.

 * are resolved to variant-level precision, meaning that if resolved variant
 * is published to different coordinates than the declared component, the
 * variant coordinates are returned.
 *
 * <p>Implementations of this class may fall-back to component-level precision when
 * variant-level precision is not available for a given dependency.</p>
 */
public interface VariantDependencyResolver {

 * are resolved to component-level precision, meaning the coordinates of the resolved
 * variant's owning component are returned.
 */
public interface ComponentDependencyResolver {

    /**
     * Determines the published coordinates for an external dependency to component-level precision.
     *
     * @return null if the external dependency could not be resolved.
     */

// This test computes the precision of the compiler's internal multiprecision floats.

package main

import (
	"fmt"
	"math"
	"runtime"
)

const ulp = (1.0 + (2.0 / 3.0)) - (5.0 / 3.0)

func main() {
	// adjust precision depending on compiler
	var prec float64
	switch runtime.Compiler {
	case "gc":
		prec = math.Inf(1) // exact precision using rational arithmetic
	case "gccgo":

	}

	return buf, nil
}

// GobDecode implements the [encoding/gob.GobDecoder] interface.
// The result is rounded per the precision and rounding mode of
// z unless z's precision is 0, in which case z is set exactly
// to the decoded value.
func (z *Float) GobDecode(buf []byte) error {
	if len(buf) == 0 {
		// Other side sent a nil or default value.
		*z = Float{}