// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package big

import (
	
	
)

var threeOnce struct {
	sync.Once
	v *Float
}

func three() *Float {
	threeOnce.Do(func() {
		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.
//
// The function panics if z < 0. The value of z is undefined in that
// case.
func ( *Float) ( *Float) *Float {
	if debugFloat {
		.validate()
	}

	if .prec == 0 {
		.prec = .prec
	}

	if .Sign() == -1 {
		// following IEEE754-2008 (section 7.2)
		panic(ErrNaN{"square root of negative operand"})
	}

	// handle ±0 and +∞
	if .form != finite {
		.acc = Exact
		.form = .form
		.neg = .neg // IEEE754-2008 requires √±0 = ±0
		return 
	}

	// MantExp sets the argument's precision to the receiver's, and
	// when z.prec > x.prec this will lower z.prec. Restore it after
	// the MantExp call.
	 := .prec
	 := .MantExp()
	.prec = 

	// Compute √(z·2**b) as
	//   √( z)·2**(½b)     if b is even
	//   √(2z)·2**(⌊½b⌋)   if b > 0 is odd
	//   √(½z)·2**(⌈½b⌉)   if b < 0 is odd
	switch  % 2 {
	case 0:
		// nothing to do
	case 1:
		.exp++
	case -1:
		.exp--
	}
	// 0.25 <= z < 2.0

	// Solving 1/x² - z = 0 avoids Quo calls and is faster, especially
	// for high precisions.
	.sqrtInverse()

	// re-attach halved exponent
	return .SetMantExp(, /2)
}

// Compute √x (to z.prec precision) by solving
//   1/t² - x = 0
// for t (using Newton's method), and then inverting.
func ( *Float) ( *Float) {
	// let
	//   f(t) = 1/t² - x
	// then
	//   g(t) = f(t)/f'(t) = -½t(1 - xt²)
	// and the next guess is given by
	//   t2 = t - g(t) = ½t(3 - xt²)
	 := newFloat(.prec)
	 := newFloat(.prec)
	 := three()
	 := func( *Float) *Float {
		.prec = .prec
		.prec = .prec
		.Mul(, )     // u = t²
		.Mul(, )     //   = xt²
		.Sub(, ) // v = 3 - xt²
		.Mul(, )     // u = t(3 - xt²)
		.exp--         //   = ½t(3 - xt²)
		return .Set()
	}

	,  := .Float64()
	 := newFloat(.prec)
	.SetFloat64(1 / math.Sqrt())
	for  := .prec + 32; .prec < ; {
		.prec *= 2
		 = ()
	}
	// sqi = 1/√x

	// x/√x = √x
	.Mul(, )
}

// newFloat returns a new *Float with space for twice the given
// precision.
func newFloat( uint32) *Float {
	 := new(Float)
	// nat.make ensures the slice length is > 0
	.mant = .mant.make(int(/_W) * 2)
	return 
}