using ops::Variable;

constexpr char kAssignOpName[] = "assign";
constexpr char kCancelOp0[] = "cancel0";
constexpr char kCancelOp1[] = "cancel1";
constexpr char kCloseOp0[] = "close0";
constexpr char kCloseOp1[] = "close1";
constexpr char kCountUpToOpName[] = "count";
constexpr char kDequeueOp0[] = "dequeue0";
constexpr char kDequeueOp1[] = "dequeue1";
constexpr char kEnqueueOp0[] = "enqueue0";
constexpr char kEnqueueOp1[] = "enqueue1";

			Goto("z1")),
		Bloc("exit",
			Exit("mem"),
		))

	CheckFunc(fun.f)
	fuseLate(fun.f)

	for k, b := range fun.blocks {
		if k[:1] == "z" && b.Kind != BlockInvalid {
			t.Errorf("case1 %s was not eliminated, but should have", k)
		}
	}

	// Case 2, empty blocks with If branch, z0 and z1 will be eliminated.
	//     entry
	//     /  \
	//    z0  z1
	//     \  /
	//     exit

// license that can be found in the LICENSE file.

package math

// Export internal functions and variable for testing.
var Log10NoVec = log10
var CosNoVec = cos
var CoshNoVec = cosh
var SinNoVec = sin
var SinhNoVec = sinh
var TanhNoVec = tanh
var Log1pNovec = log1p
var AtanhNovec = atanh
var AcosNovec = acos
var AcoshNovec = acosh
var AsinNovec = asin
var AsinhNovec = asinh

		t.Skipf("no vector support")
	}
	for i := 0; i < len(vf); i++ {
		if f := CoshNoVec(vf[i]); !close(cosh[i], f) {
			t.Errorf("Cosh(%g) = %g, want %g", vf[i], f, cosh[i])
		}
	}
	for i := 0; i < len(vfcoshSC); i++ {
		if f := CoshNoVec(vfcoshSC[i]); !alike(coshSC[i], f) {
			t.Errorf("Cosh(%g) = %g, want %g", vfcoshSC[i], f, coshSC[i])
		}
	}
}
func TestSinNovec(t *testing.T) {
	if !HasVX {
		t.Skipf("no vector support")

//      MINLOG = -8.872283911167299960540e+01 = log(2**-128)
//
// A rational function is used for |x| < 0.625.  The form
// x + x**3 P(x)/Q(x) of Cody & Waite is employed.
// Otherwise,
//      tanh(x) = sinh(x)/cosh(x) = 1  -  2/(exp(2x) + 1).
//
// ACCURACY:
//
//                      Relative error:
// arithmetic   domain     # trials      peak         rms
//    IEEE      -2,2        30000       2.5e-16     5.8e-17
//

}

TEST_F(CWiseUnaryGradTest, Cosh) {
  auto x_fn = [this](const int i) { return RV({0, -1, 1, -2, 2, -3, 3}); };
  TestCWiseGrad<float, float>(COSH, x_fn);
}

TEST_F(CWiseUnaryGradTest, Cosh_Complex) {
  auto x_fn = [this](const int i) {
    return CRV({{0.5, 0.25}, {0.25, 0.5}, {1.5, -1}, {1, 1.5}});
  };
  TestCWiseGrad<complex64, complex64>(COSH, x_fn);
}

TEST_F(CWiseUnaryGradTest, Tanh) {

	fmt.Printf("%.2f", math.Copysign(3.2, -1))
	// Output: -3.20
}

func ExampleCos() {
	fmt.Printf("%.2f", math.Cos(math.Pi/2))
	// Output: 0.00
}

func ExampleCosh() {
	fmt.Printf("%.2f", math.Cosh(0))
	// Output: 1.00
}

func ExampleSin() {
	fmt.Printf("%.2f", math.Sin(math.Pi))
	// Output: 0.00
}

func ExampleSincos() {
	sin, cos := math.Sincos(0)
	fmt.Printf("%.2f, %.2f", sin, cos)

TEXT ·coshTrampolineSetup(SB), NOSPLIT, $0
	MOVB   ·hasVX(SB), R1
	CMPBEQ R1, $1, vectorimpl                // vectorfacility = 1, vector supported
	MOVD   $·coshvectorfacility+0x00(SB), R1
	MOVD   $·cosh(SB), R2
	MOVD   R2, 0(R1)
	BR     ·cosh(SB)

vectorimpl:
	MOVD $·coshvectorfacility+0x00(SB), R1
	MOVD $·coshAsm(SB), R2
	MOVD R2, 0(R1)
	BR   ·coshAsm(SB)

GLOBL ·coshvectorfacility+0x00(SB), NOPTR, $8

func send2(ch chan string, x string) bool { // ERROR "ch does not escape" "leaking param: x$"
	vc := reflect.ValueOf(ch)
	vx := reflect.ValueOf(x) // ERROR "x escapes to heap"
	return vc.TrySend(vx)
}

func close1(ch chan string) { // ERROR "ch does not escape"
	v := reflect.ValueOf(ch)
	v.Close()
}

func select1(ch chan string) string { // ERROR "leaking param: ch$"
	v := reflect.ValueOf(ch)

        TypeID::get<TF::ComplexAbsOp>(),
        TypeID::get<TF::ConjugateTransposeOp>(),
        TypeID::get<TF::ConcatV2Op>(),
        TypeID::get<TF::ConvOp>(),
        TypeID::get<TF::CoshOp>(),
        TypeID::get<TF::CrossOp>(),
        TypeID::get<TF::CumulativeLogsumexpOp>(),
        TypeID::get<TF::DataFormatDimMapOp>(),
        TypeID::get<TF::DataFormatVecPermuteOp>(),