File Manager

✏️ /

// 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 (
	"math"
	"sync"
)

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 (z *Float) Sqrt(x *Float) *Float {
	if debugFloat {
		x.validate()
	}

if z.prec == 0 {
		z.prec = x.prec
	}

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

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

// 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 := z.prec
	b := x.MantExp(z)
	z.prec = 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 b % 2 {
	case 0:
		// nothing to do
	case 1:
		z.exp++
	case -1:
		z.exp--
	}
	// 0.25 <= z < 2.0

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

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

// Compute √x (to z.prec precision) by solving
//
//	1/t² - x = 0
//
// for t (using Newton's method), and then inverting.
func (z *Float) sqrtInverse(x *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²)
	u := newFloat(z.prec)
	v := newFloat(z.prec)
	three := three()
	ng := func(t *Float) *Float {
		u.prec = t.prec
		v.prec = t.prec
		u.Mul(t, t)     // u = t²
		u.Mul(x, u)     //   = xt²
		v.Sub(three, u) // v = 3 - xt²
		u.Mul(t, v)     // u = t(3 - xt²)
		u.exp--         //   = ½t(3 - xt²)
		return t.Set(u)
	}

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

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

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

Batal

⬅ math 60 item

Nama	Tipe	Ukuran	Diubah	Aksi
🔵accuracy_string.go	go	647 B	2024-02-02 18:09	✏️ 👁️
🔵alias_test.go	go	8.8 KB	2024-02-02 18:09	✏️ 👁️
🔵arith.go	go	8.3 KB	2024-02-02 18:09	✏️ 👁️
📄arith_386.s	s	4 KB	2024-02-02 18:09	✏️ 👁️
🔵arith_amd64.go	go	278 B	2024-02-02 18:09	✏️ 👁️
📄arith_amd64.s	s	9.1 KB	2024-02-02 18:09	✏️ 👁️
📄arith_arm.s	s	4 KB	2024-02-02 18:09	✏️ 👁️
📄arith_arm64.s	s	11.8 KB	2024-02-02 18:09	✏️ 👁️
🔵arith_decl.go	go	686 B	2024-02-02 18:09	✏️ 👁️
🔵arith_decl_pure.go	go	1 KB	2024-02-02 18:09	✏️ 👁️
🔵arith_decl_s390x.go	go	503 B	2024-02-02 18:09	✏️ 👁️
📄arith_loong64.s	s	749 B	2024-02-02 18:09	✏️ 👁️
📄arith_mips64x.s	s	763 B	2024-02-02 18:09	✏️ 👁️
📄arith_mipsx.s	s	759 B	2024-02-02 18:09	✏️ 👁️
📄arith_ppc64x.s	s	16.4 KB	2024-02-02 18:09	✏️ 👁️
📄arith_riscv64.s	s	750 B	2024-02-02 18:09	✏️ 👁️
📄arith_s390x.s	s	20.3 KB	2024-02-02 18:09	✏️ 👁️
🔵arith_s390x_test.go	go	770 B	2024-02-02 18:09	✏️ 👁️
🔵arith_test.go	go	19.9 KB	2024-02-02 18:09	✏️ 👁️
📄arith_wasm.s	s	613 B	2024-02-02 18:09	✏️ 👁️
🔵bits_test.go	go	5.1 KB	2024-02-02 18:09	✏️ 👁️
🔵calibrate_test.go	go	4.6 KB	2024-02-02 18:09	✏️ 👁️
🔵decimal.go	go	6.6 KB	2024-02-02 18:09	✏️ 👁️
🔵decimal_test.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵doc.go	go	3.8 KB	2024-02-02 18:09	✏️ 👁️
🔵example_rat_test.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
🔵example_test.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵float.go	go	44.6 KB	2024-02-02 18:09	✏️ 👁️
🔵float_test.go	go	51.9 KB	2024-02-02 18:09	✏️ 👁️
🔵floatconv.go	go	8.3 KB	2024-02-02 18:09	✏️ 👁️
🔵floatconv_test.go	go	24.3 KB	2024-02-02 18:09	✏️ 👁️
🔵floatexample_test.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵floatmarsh.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵floatmarsh_test.go	go	4.5 KB	2024-02-02 18:09	✏️ 👁️
🔵ftoa.go	go	13.5 KB	2024-02-02 18:09	✏️ 👁️
🔵gcd_test.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵hilbert_test.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵int.go	go	33.2 KB	2024-02-02 18:09	✏️ 👁️
🔵int_test.go	go	58.5 KB	2024-02-02 18:09	✏️ 👁️
🔵intconv.go	go	6.7 KB	2024-02-02 18:09	✏️ 👁️
🔵intconv_test.go	go	10 KB	2024-02-02 18:09	✏️ 👁️
🔵intmarsh.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵intmarsh_test.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵link_test.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵nat.go	go	31.8 KB	2024-02-02 18:09	✏️ 👁️
🔵nat_test.go	go	26.2 KB	2024-02-02 18:09	✏️ 👁️
🔵natconv.go	go	14.6 KB	2024-02-02 18:09	✏️ 👁️
🔵natconv_test.go	go	16.8 KB	2024-02-02 18:09	✏️ 👁️
🔵natdiv.go	go	34.4 KB	2024-02-02 18:09	✏️ 👁️
🔵prime.go	go	10.4 KB	2024-02-02 18:09	✏️ 👁️
🔵prime_test.go	go	7.1 KB	2024-02-02 18:09	✏️ 👁️
🔵rat.go	go	13.5 KB	2024-02-02 18:09	✏️ 👁️
🔵rat_test.go	go	18.9 KB	2024-02-02 18:09	✏️ 👁️
🔵ratconv.go	go	12.3 KB	2024-02-02 18:09	✏️ 👁️
🔵ratconv_test.go	go	19.3 KB	2024-02-02 18:09	✏️ 👁️
🔵ratmarsh.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵ratmarsh_test.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵roundingmode_string.go	go	819 B	2024-02-02 18:09	✏️ 👁️
🔵sqrt.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵sqrt_test.go	go	4.8 KB	2024-02-02 18:09	✏️ 👁️

✏️ Rename