Golang math.Frexp函数代码示例

// SetFloat64 sets z to the (possibly rounded) value of x and returns z.
// If z's precision is 0, it is changed to 53 (and rounding will have
// no effect). SetFloat64 panics with ErrNaN if x is a NaN.
func (z *Float) SetFloat64(x float64) *Float {
	if z.prec == 0 {
		z.prec = 53
	}
	if math.IsNaN(x) {
		panic(ErrNaN{"Float.SetFloat64(NaN)"})
	}
	z.acc = Exact
	z.neg = math.Signbit(x) // handle -0, -Inf correctly
	if x == 0 {
		z.form = zero
		return z
	}
	if math.IsInf(x, 0) {
		z.form = inf
		return z
	}
	// normalized x != 0
	z.form = finite
	fmant, exp := math.Frexp(x) // get normalized mantissa
	z.mant = z.mant.setUint64(1<<63 | math.Float64bits(fmant)<<11)
	z.exp = int32(exp) // always fits
	if z.prec < 53 {
		z.round(0)
	}
	return z
}

// Return the maximum level such that the length is at least the given value,
// or zero if there is no such level. The return value is always a valid level.
func (m Metric) MaxLevel(value float64) int {
	if value <= 0 {
		return maxLevel
	}
	_, level := math.Frexp(m.Deriv / value)
	level = max(0, min(maxLevel, (level-1)>>uint(m.dim-1)))
	return level
}

// Return the minimum level such that the length is at most the given value,
// or maxLevel if there is no such level. The return value is always a valid
// level.
func (m Metric) MinLevel(value float64) int {
	if value <= 0 {
		return maxLevel
	}
	// This code is equivalent to computing a floating-point "level"
	// value and rounding up. Frexp() returns a fraction in the range
	// [0.5, 1) and the corresponding exponent.
	_, level := math.Frexp(value / m.Deriv)
	level = max(0, min(maxLevel, -((level-1)>>uint(m.dim-1))))
	return level
}

// give the binary representation of integer s
func toBinary(s int) []int {
	_, t := math.Frexp(float64(s))
	var (
		bit = s
		bin = make([]int, t)
	)
	for k := t - 1; k >= 0; k-- {
		bin[k] = bit % 2
		bit /= 2
	}
	return bin
}

// Return the smallest number integer k where 2^k is greater than
// or equal to n.
//
// XXX DEPRECATED
func NextExp2(n uint) (k uint) {

	if n == 0 || n == uint(1) {
		k = uint(0)
	} else if n == uint(2) {
		k = uint(1)
	} else {
		f := float64(n)
		frac, exp := math.Frexp(f)
		//we are guaranteed that frac is in [1/2, 1)
		if frac == float64(0.5) {
			k = uint(exp - 1)
		} else {
			k = uint(exp)
		}
	}
	return k
}

// Return the smallest number k which is a power of two and greater than
// or equal to n.
//
// XXX DEPRECATED
func NextPow2(n uint) (k uint) {

	if n == 0 {
		k = uint(1)
	} else if n == uint(1) || n == uint(2) {
		k = n
	} else {
		f := float64(n)
		frac, exp := math.Frexp(f)
		//we are guaranteed that frac is in [1/2, 1)
		if frac == float64(0.5) {
			k = n
		} else {
			k = uint(math.Pow(float64(2), float64(exp)))
		}
	}
	return k
}

func NewExactFloat(v float64) ExactFloat {
	f := ExactFloat{bn: big.NewInt(0)}
	sb := math.Signbit(v)
	if sb {
		f.sign = -1
	} else {
		f.sign = 1
	}
	if math.IsNaN(v) {
		f.set_nan()
	} else if math.IsInf(v, int(f.sign)) {
		f.set_inf(f.sign)
	} else {
		frac, exp := math.Frexp(math.Abs(v))
		m := uint64(math.Ldexp(frac, doubleMantissaBits))
		f.bn = f.bn.SetUint64(m)
		f.bn_exp = exp - doubleMantissaBits
		f.Canonicalize()
	}
	return f
}

func Mpmovecflt(a *Mpflt, c float64) {
	if Mpdebug != 0 /*TypeKind(100016)*/ {
		fmt.Printf("\nconst %g", c)
	}
	Mpmovecfix(&a.Val, 0)
	a.Exp = 0
	var f float64
	var l int
	var i int
	if c == 0 {
		goto out
	}
	if c < 0 {
		a.Val.Neg = 1
		c = -c
	}

	f, i = math.Frexp(c)
	a.Exp = int16(i)

	for i := 0; i < 10; i++ {
		f = f * Mpbase
		l = int(math.Floor(f))
		f = f - float64(l)
		a.Exp -= Mpscale
		a.Val.A[0] = l
		if f == 0 {
			break
		}
		Mpshiftfix(&a.Val, Mpscale)
	}

out:
	mpnorm(a)
	if Mpdebug != 0 /*TypeKind(100016)*/ {
		fmt.Printf(" = %v\n", Fconv(a, 0))
	}
}

func NewFreeze(d time.Duration, in Sound) *Freeze {
	f := Dtof(d, in.SampleRate())

	n := f
	if n == 0 || n&(n-1) != 0 {
		_, e := math.Frexp(float64(n))
		n = int(math.Ldexp(1, e))
	}

	frz := &Freeze{mono: newmono(nil), prv: make(Discrete, n)}
	frz.sig = frz.prv[:f]

	inps := GetInputs(in)
	dp := new(Dispatcher)

	// t := time.Now()
	for i := 0; i < n; i += in.BufferLen() {
		dp.Dispatch(1, inps...)
		ringcopy(frz.sig[i:i+in.BufferLen()], in.Samples(), 0)
	}
	// log.Println("freeze took", time.Now().Sub(t))
	return frz
}

// Return P(document is in category | document)
func (bc *BayesianClassifier) CategoryProbabilities(text string, categories []string) (map[string]float64, error) {
	tokens, err := bc.tokenizer.Tokenize(text)
	if err != nil {
		return nil, err
	}
	probs, err := bc.filteredProbabilities(tokens, categories)
	if err != nil {
		return nil, err
	}

	// Fisher's method for combining probabilities
	catProb := make(map[string]float64, len(categories))
	for cat, pr := range probs {
		p := 0.5
		n := len(pr)
		if n > 0 {
			p = 1.0
			pExp := 0.0
			for _, tp := range pr {
				p *= tp
				if p < 1e-200 { // prevent underflow
					var e int
					p, e = math.Frexp(p)
					pExp += float64(e)
				}
			}
			// Compute the natural log of the product = sum of the logs:
			// ln(x * 2**i) = ln(x) + i * ln(2).
			p = -2.0 * (math.Log(p) + pExp*math.Ln2)
			p = invChi2(p, 2*n)
		}
		catProb[cat] = p
	}

	return catProb, nil
}

func Frexp(f float32) (frac float32, exp int) {
	frac64, exp := math.Frexp(float64(f))
	frac = float32(frac64)
	return
}

func ext۰math۰Frexp(fr *Frame, args []Value) Value {
	frac, int := math.Frexp(args[0].(float64))
	return tuple{frac, int}
}

func ftoa(f float64, prec int) string {
	fr, exp := math.Frexp(f)
	v := int64(fr * (1 << 53))
	e := exp - 53

	buf := make([]byte, 1000)
	n := copy(buf, strconv.FormatInt(v, 10))
	//n := copy(buf, strconv.Itoa64(v))

	for ; e > 0; e-- {
		δ := 0
		if buf[0] >= '5' {
			δ = 1
		}
		x := byte(0)
		for i := n - 1; i >= 0; i-- {
			x += 2 * (buf[i] - '0')
			x, buf[i+δ] = x/10, x%10+'0'
		}
		if δ == 1 {
			buf[0] = '1'
			n++
		}
	}
	dp := n

	for ; e < 0; e++ {
		if buf[n-1]%2 != 0 {
			buf[n] = '0'
			n++
		}
		δ, x := 0, byte(0)
		if buf[0] < '2' {
			δ, x = 1, buf[0]-'0'
			n--
			dp--
		}
		for i := 0; i < n; i++ {
			x = x*10 + buf[i+δ] - '0'
			buf[i], x = x/2+'0', x%2
		}
	}

	if prec > 0 {
		if n > prec {
			if buf[prec] > '5' || buf[prec] == '5' && (nonzero(buf[prec+1:n]) || buf[prec-1]%2 == 1) {
				i := prec - 1
				for i >= 0 && buf[i] == '9' {
					buf[i] = '0'
					i--
				}
				if i >= 0 {
					buf[i]++
				} else {
					buf[0] = '1'
					dp++
				}
			}
			n = prec
		}
		for n < prec {
			buf[n] = '0'
			n++
		}
	}
	return fmt.Sprintf("%c.%se%+d", buf[0], buf[1:n], dp-1)
}

var mathLibrary = []RegistryFunction{
	{"abs", mathUnaryOp(math.Abs)},
	{"acos", mathUnaryOp(math.Acos)},
	{"asin", mathUnaryOp(math.Asin)},
	{"atan2", mathBinaryOp(math.Atan2)},
	{"atan", mathUnaryOp(math.Atan)},
	{"ceil", mathUnaryOp(math.Ceil)},
	{"cosh", mathUnaryOp(math.Cosh)},
	{"cos", mathUnaryOp(math.Cos)},
	{"deg", mathUnaryOp(func(x float64) float64 { return x / radiansPerDegree })},
	{"exp", mathUnaryOp(math.Exp)},
	{"floor", mathUnaryOp(math.Floor)},
	{"fmod", mathBinaryOp(math.Mod)},
	{"frexp", func(l *State) int {
		f, e := math.Frexp(CheckNumber(l, 1))
		l.PushNumber(f)
		l.PushInteger(e)
		return 2
	}},
	{"ldexp", func(l *State) int {
		x, e := CheckNumber(l, 1), CheckInteger(l, 2)
		l.PushNumber(math.Ldexp(x, e))
		return 1
	}},
	{"log", func(l *State) int {
		x := CheckNumber(l, 1)
		if l.IsNoneOrNil(2) {
			l.PushNumber(math.Log(x))
		} else if base := CheckNumber(l, 2); base == 10.0 {
			l.PushNumber(math.Log10(x))

func mathFrexp(L *LState) int {
	v1, v2 := math.Frexp(float64(L.CheckNumber(1)))
	L.Push(LNumber(v1))
	L.Push(LNumber(v2))
	return 2
}