type float64 float64

// complex64 is the set of all complex numbers with float32 real and
// imaginary parts.
type complex64 complex64

// complex128 is the set of all complex numbers with float64 real and
// imaginary parts.
type complex128 complex128

// string is the set of all strings of 8-bit bytes, conventionally but not
// necessarily representing UTF-8-encoded text. A string may be empty, but

pkg os, method (*File) ReadFrom(io.Reader) (int64, error)
pkg os, var ErrDeadlineExceeded error
pkg regexp, method (*Regexp) SubexpIndex(string) int
pkg strconv, func FormatComplex(complex128, uint8, int, int) string
pkg strconv, func ParseComplex(string, int) (complex128, error)
pkg sync, method (*Map) LoadAndDelete(interface{}) (interface{}, bool)
pkg testing, method (*B) TempDir() string
pkg testing, method (*T) Deadline() (time.Time, bool)

pkg reflect, method (Value) Seq2() iter.Seq2[Value, Value] #66056
pkg reflect, type Type interface, CanSeq() bool #66056
pkg reflect, type Type interface, CanSeq2() bool #66056
pkg reflect, type Type interface, OverflowComplex(complex128) bool #60427
pkg reflect, type Type interface, OverflowFloat(float64) bool #60427
pkg reflect, type Type interface, OverflowInt(int64) bool #60427
pkg reflect, type Type interface, OverflowUint(uint64) bool #60427

  virtual AbstractTensorInterface* CreateHalfScalar(Eigen::half value) = 0;
  virtual AbstractTensorInterface* CreateStringScalar(tstring value) = 0;
  virtual AbstractTensorInterface* CreateComplex128Scalar(complex128 value) = 0;
  virtual AbstractTensorInterface* CreateBoolScalar(bool value) = 0;

  // Tensor creation functions
  virtual AbstractTensorInterface* CreateTensor(

pkg go/types, const Bool = 1
pkg go/types, const Bool BasicKind
pkg go/types, const Byte = 8
pkg go/types, const Byte BasicKind
pkg go/types, const Complex128 = 16
pkg go/types, const Complex128 BasicKind
pkg go/types, const Complex64 = 15
pkg go/types, const Complex64 BasicKind
pkg go/types, const FieldVal = 0
pkg go/types, const FieldVal SelectionKind
pkg go/types, const Float32 = 13

pkg math/cmplx, func Polar(complex128) (float64, float64)
pkg math/cmplx, func Pow(complex128, complex128) complex128
pkg math/cmplx, func Rect(float64, float64) complex128
pkg math/cmplx, func Sin(complex128) complex128
pkg math/cmplx, func Sinh(complex128) complex128
pkg math/cmplx, func Sqrt(complex128) complex128
pkg math/cmplx, func Tan(complex128) complex128
pkg math/cmplx, func Tanh(complex128) complex128

yields a typed constant.
</p>

<pre>
uint(iota)               // iota value of type uint
float32(2.718281828)     // 2.718281828 of type float32
complex128(1)            // 1.0 + 0.0i of type complex128
float32(0.49999999)      // 0.5 of type float32
float64(-1e-1000)        // 0.0 of type float64
string('x')              // "x" of type string
string(0x266c)           // "♬" of type string

				}
			}
		case reflect.Invalid, reflect.Uintptr, reflect.Array, reflect.Chan, reflect.Func, reflect.Interface,
			reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer, reflect.Complex64, reflect.Complex128:
			schema.err = fmt.Errorf("invalid embedded struct for %s's field %s, should be struct, but got %v", field.Schema.Name, field.Name, field.FieldType)
		}
	}

	return field
}

        `tf.float64` (for which there was no GPU implementation). In this
        current release, GPU support for other floating-point types
        (`tf.float16`, `tf.float64`, `tf.complex64`, and `tf.complex128`) has
        been added for this op. If you were relying on the determinism of the
        `tf.float64` CPU implementation being automatically selected because of

pkg path/filepath (windows-amd64), const Separator = 92
pkg reflect, const Array = 17
pkg reflect, const Bool = 1
pkg reflect, const BothDir = 3
pkg reflect, const Chan = 18
pkg reflect, const Complex128 = 16
pkg reflect, const Complex64 = 15
pkg reflect, const Float32 = 13
pkg reflect, const Float64 = 14
pkg reflect, const Func = 19
pkg reflect, const Int = 2
pkg reflect, const Int16 = 4