Source File
sqrt.go
Belonging Package
math/big
// 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
}
![]() |
The pages are generated with Golds v0.6.9-preview. (GOOS=linux GOARCH=amd64) Golds is a Go 101 project developed by Tapir Liu. PR and bug reports are welcome and can be submitted to the issue list. Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |