// // complex types.
// type ComplexAbs[T Complex] T
// 
// func (a ComplexAbs[T]) Abs() ComplexAbs[T] {
// 	r := float64(real(a))
// 	i := float64(imag(a))
// 	d := math.Sqrt(r * r + i * i)
// 	return ComplexAbs[T](complex(d, 0))
// }
// 
// func OrderedAbsDifference[T OrderedNumeric](a, b T) T {
// 	return T(AbsDifference(OrderedAbs[T](a), OrderedAbs[T](b)))
// }
// 

   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code
   *     sqrt(x)} is not an integer
   */
  @GwtIncompatible // need BigIntegerMath to adequately test
  @SuppressWarnings("fallthrough")
  public static int sqrt(int x, RoundingMode mode) {
    checkNonNegative("x", x);
    int sqrtFloor = sqrtFloor(x);
    switch (mode) {
      case UNNECESSARY:

   * @throws ArithmeticException if {@code mode} is {@link RoundingMode#UNNECESSARY} and {@code
   *     sqrt(x)} is not an integer
   */
  @GwtIncompatible // need BigIntegerMath to adequately test
  @SuppressWarnings("fallthrough")
  public static int sqrt(int x, RoundingMode mode) {
    checkNonNegative("x", x);
    int sqrtFloor = sqrtFloor(x);
    switch (mode) {
      case UNNECESSARY:

   * R*R)} of the population standard deviation of {@code y}, where {@code R} is the Pearson's
   * correlation coefficient (as given by {@link #pearsonsCorrelationCoefficient()}).
   *
   * <p>The corresponding root-mean-square error in {@code x} as a function of {@code y} is a
   * fraction {@code sqrt(1/(R*R) - 1)} of the population standard deviation of {@code x}. This fit

	NEGD	F0, F1, F2         // ERROR "illegal combination"
	ABSF	F0, F1, F2         // ERROR "illegal combination"
	ABSD	F0, F1, F2         // ERROR "illegal combination"
	SQRTF	F0, F1, F2         // ERROR "illegal combination"
	SQRTD	F0, F1, F2         // ERROR "illegal combination"
	MOVF	F0, F1, F2         // ERROR "illegal combination"
	MOVD	F0, F1, F2         // ERROR "illegal combination"

	switch {
	case math.IsNaN(x) || math.IsInf(x, 1):
		return x
	case x < 0:
		return math.NaN()
	case x == 0:
		return math.Inf(-1)
	}

	// reduce
	f1, ki := math.Frexp(x)
	if f1 < math.Sqrt2/2 {
		f1 *= 2
		ki--
	}
	f := f1 - 1
	k := float64(ki)

	// compute
	s := float64(f / (2 + f))
	s2 := float64(s * s)
	s4 := float64(s2 * s2)

	}
	return
}

func ComplexAbs[T Complex](a T) T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a)
	// r := float64(real(a))
	// i := float64(imag(a))
	d := math.Sqrt(r*r + i*i)
	return T(complex(d, 0))
}

// OrderedAbsDifference returns the absolute value of the difference
// between a and b, where a and b are of an ordered type.
func OrderedAbsDifference[T OrderedNumeric](a, b T) T {

   * R*R)} of the population standard deviation of {@code y}, where {@code R} is the Pearson's
   * correlation coefficient (as given by {@link #pearsonsCorrelationCoefficient()}).
   *
   * <p>The corresponding root-mean-square error in {@code x} as a function of {@code y} is a
   * fraction {@code sqrt(1/(R*R) - 1)} of the population standard deviation of {@code x}. This fit

  // y = a * x
  auto y = MatMul(root.WithOpName("y"), a, x);
  // y2 = y.^2
  auto y2 = Square(root, y);
  // y2_sum = sum(y2)
  auto y2_sum = Sum(root, y2, 0);
  // y_norm = sqrt(y2_sum)
  auto y_norm = Sqrt(root, y2_sum);
  // y_normalized = y ./ y_norm
  auto y_normalized = Div(root.WithOpName("y_normalized"), y, y_norm);
  Tensor out;
  test::GetTensor(root, y_normalized, &out);

}

func (a complexAbs[T]) Abs() T {
	// TODO use direct conversion instead of realimag once #50937 is fixed
	r, i := realimag(a.Value_)
	// r := float64(real(a.Value))
	// i := float64(imag(a.Value))
	d := math.Sqrt(r*r + i*i)
	return T(complex(d, 0))
}

func (a complexAbs[T]) Value() T {
	return a.Value_
}

// OrderedAbsDifference returns the absolute value of the difference