Golang math.Fmin函数代码示例

func (l Line) WeightedIterator() (pix []WeightedPoint) {

	max_delta := 2.0 * l.radius // will miss prob mass outside of 2 std dev
	normalizer := 1.0 / math.Sqrt(2.0*math.Pi*l.radius*l.radius)

	var p image.Point
	cur := l.left
	iter := int(math.Fmax(math.Fabs(l.Dx()), math.Fabs(l.Dy()))) + 1
	dx := l.Dx() / float64(iter)
	dy := l.Dy() / float64(iter)

	for i := 0; i < iter; i++ {
		for d := -max_delta; d < max_delta; d += 1.0 {

			if dx > dy { // vertical sweeps
				p = image.Point{int(cur.X), int(cur.Y + d)}
			} else { // horizontal sweeps
				p = image.Point{int(cur.X + d), int(cur.Y)}
			}

			fp := NewFloat64Point(p)
			dist := l.Distance(fp.X, fp.Y)
			dist = math.Fmin(dist, Distance(fp, l.left))
			dist = math.Fmin(dist, Distance(fp, l.right))
			weight := normalizer * math.Exp(-dist*dist/(2.0*l.radius*l.radius))

			pix = append(pix, WeightedPoint{p, weight})
		}
		cur.X += dx
		cur.Y += dy
	}
	return pix
}

// calculate the closest distance between to locations
func (m *Map) Distance(srcLoc, destLoc Location) float64 {
	row1, col1 := m.FromLocation(srcLoc)
	row2, col2 := m.FromLocation(destLoc)
	dCol := math.Fmin(math.Fabs(float64(col1-col2)), float64(m.Cols)-math.Fabs(float64(col1-col2)))
	dRow := math.Fmin(math.Fabs(float64(row1-row2)), float64(m.Rows)-math.Fabs(float64(row1-row2)))
	return dCol + dRow
}

func DrawTable(r io.Writer, t *DataTable, w uint, h uint) os.Error {

	var minVal float64
	var maxVal float64

	for _, v := range t.Values {
		if v != nil {
			f64 := float64(v.Float64Value())
			minVal = math.Fmin(minVal, f64)
			maxVal = math.Fmax(maxVal, f64)
		}
	}

	i := image.NewRGBA(int(w), int(h))
	gc := draw2d.NewGraphicContext(i)
	dx := float64(w-1) / (float64(t.End) - float64(t.Start))
	dy := float64(h-1) / (maxVal - minVal)

	gc.SetLineWidth(1)
	for i, v := range t.Values {
		if v == nil {
			continue
		}
		x := dx * float64(int64(i)*t.Resolution)
		y := dy * (float64(v.Float64Value()) - minVal)
		gc.MoveTo(x+0.45, y+0.5)
		gc.ArcTo(x+0.5, y+0.5, 0.1, 0.1, 0, -math.Pi*2)
		gc.Stroke()
	}

	return png.Encode(r, i)
}

func (s *Statistics) ComputeScore(c *Combat) {
	// we are more aggresive towards players we outnumber esp if
	// we have the most ant however if we have not seen much of the
	// map we are risk averse
	if s.LTS == nil {
		return
	}
	// fraction of map seen
	vis := .1
	if c != nil {
		vis = float64(c.Size()-s.LTS.Horizon) / float64(c.Size())
	}

	frac := float64(s.LTS.Seen[0]) / float64(s.LTS.SeenAll)

	for i := range s.LTS.Seen {
		if TurnGet() < 60 { // MAGIC
			s.LTS.Score[i] = .4
		} else {
			frace := float64(s.LTS.Seen[i]) / float64(s.LTS.SeenAll)
			s.LTS.Score[i] = math.Fmax(math.Fmin(frac*vis*vis/frace, 2.0), .3)
		}
	}
	s.LTS.Score[0] = -1.5

	if Debug[DBG_Scoring] {
		log.Print("Score per player is ", s.LTS.Score[0:s.NP])
	}
}

func (this *northEastHandle) InvokeStep(x, y, anchorX, anchorY int, view DrawingView) {
	r := this.owner.GetDisplayBox()
	this.owner.SetDisplayBox(
		this.owner,
		&Point{r.X, int(math.Fmin(float64(r.Y+r.Height), float64(y)))},
		&Point{int(math.Fmax(float64(r.X), float64(x))), r.Y + r.Height})
}

func (node *Node) recalc() {
	if node.Visits == 10 {
		node.value = 1 + 0.1*rand.Float64()
		return
	}
	node.Mean = node.Wins / node.Visits
	node.blendedMean = node.Mean
	rave := node.config.AMAF || node.config.Neighbors || node.config.Ancestor
	if rave {
		beta := math.Sqrt(node.config.RAVE / (3*node.Visits + node.config.RAVE))
		if beta > 0 {
			node.amafMean = node.amafWins / node.amafVisits
			node.ancestorMean = node.ancestorWins / node.ancestorVisits
			if math.IsNaN(node.Mean) {
				node.Mean = 0
			}
			if math.IsNaN(node.amafMean) {
				node.amafMean = 0
			}
			if math.IsNaN(node.ancestorMean) {
				node.ancestorMean = 0
			}
			estimatedMean := 0.0
			Samples := 0.0
			if node.config.AMAF {
				estimatedMean += node.amafMean
				Samples++
			}
			if node.config.Neighbors {
				neighborWins := 0.0
				neighborVisits := 0.0
				for sibling := node.parent.Child; sibling != nil; sibling = sibling.Sibling {
					if sibling.Vertex != node.Vertex {
						neighborWins += sibling.Wins
						neighborVisits += sibling.Visits
					}
				}
				estimatedMean += neighborWins / neighborVisits
			}
			if node.config.Ancestor {
				estimatedMean += node.ancestorMean
				Samples++
			}
			estimatedMean /= Samples
			if math.IsNaN(estimatedMean) {
				estimatedMean = 0
			}
			node.blendedMean = beta*estimatedMean + (1-beta)*node.Mean
		}
	}
	r := math.Log1p(node.parent.Visits) / node.Visits
	v := 1.0
	if node.config.Var {
		v = math.Fmin(0.25, node.blendedMean-(node.blendedMean*node.blendedMean)+math.Sqrt(2*r))
	}
	node.value = node.blendedMean + node.config.Explore*math.Sqrt(r*v)
}

func fit(trans []*affine.Affine) (x1, y1, x2, y2 float64) {
	org := trans[0].GetOrigin()
	x2 = org.Get(0, 0)
	x1 = x2
	y2 = org.Get(1, 0)
	y1 = y2
	nx1, ny1, nx2, ny2 := x1, y1, x2, y2
	done := false
	for !done {
		//print (x1,x2,y1,y2,"\n")
		for i := 0; i < 4; i++ {
			xx := x1
			yy := y1
			if i%2 == 0 {
				xx = x2
			}
			if i > 1 {
				yy = y2
			}
			for _, t := range trans {
				x, y := t.Trans(xx, yy)
				nx1 = math.Fmin(nx1, x)
				nx2 = math.Fmax(nx2, x)
				ny1 = math.Fmin(ny1, y)
				ny2 = math.Fmax(ny2, y)
			}
		}
		if nx1 > x1 && nx2 < x2 && ny1 > y1 && ny2 < y2 {
			done = true
		}
		x1, y1, x2, y2 = nx1, ny1, nx2, ny2
		dx := nx2 - nx1
		const f = .001
		x1 -= dx * f
		x2 += dx * f
		dy := ny2 - ny1
		y1 -= dy * f
		y2 += dy * f

	}
	return
}

func genArray(n int) []interface{} {
	f := int(math.Fabs(rand.NormFloat64()) * math.Fmin(10, float64(n/2)))
	if f > n {
		f = n
	}
	x := make([]interface{}, int(f))
	for i := range x {
		x[i] = genValue(((i+1)*n)/f - (i*n)/f)
	}
	return x
}

func MakeACGenEdit(Gp [][]string, c []float64) func(string, string) float64 {
	Proot := MakeLinkedGoto(Gp[0])
	MakeLinkedFail(Proot)
	Troot := MakeLinkedGoto(Gp[1])
	MakeLinkedFail(Troot)
	G := make([][]*utf8.String, len(Gp))
	for i, _ := range G {
		G[i] = make([]*utf8.String, len(Gp[i]))
		for j, _ := range G[i] {
			G[i][j] = utf8.NewString(Gp[i][j])
		}
	}

	return func(pattern string, text string) float64 {
		P := utf8.NewString(pattern + " ")
		PLen := P.RuneCount() - 1
		T := utf8.NewString(text + " ")
		TLen := T.RuneCount() - 1
		d := makeMatrix(TLen+1, PLen+1)
		p := NewBitArray(len(Gp[0]))

		Pstate := Proot
		Tstate := Troot

		for x := 0; x <= PLen; x++ {
			Tstate = Troot
			for y := 0; y <= TLen; y++ {
				if x == 0 && y == 0 {
					d[y][x] = 0
				} else {
					d[y][x] = math.Inf(1)
					if x > 0 && y > 0 && Pstate.symbol == Tstate.symbol {
						d[y][x] = d[y-1][x-1]
					}
					if len(Pstate.output) > 0 && len(Tstate.output) > 0 {
						p = p.Intersection(Pstate.output, Tstate.output)
						p.ForEach(func(i int) {
							a := x - G[0][i].RuneCount()
							b := y - G[1][i].RuneCount()
							d[y][x] = math.Fmin(d[y][x], d[b][a]+c[i])
						})
					}
				}
				Tstate = Tstate.Push(T.At(y))
			}
			Pstate = Pstate.Push(P.At(x))
		}

		return d[TLen][PLen]
	}
}

func genMap(n int) map[string]interface{} {
	f := int(math.Fabs(rand.NormFloat64()) * math.Fmin(10, float64(n/2)))
	if f > n {
		f = n
	}
	if n > 0 && f == 0 {
		f = 1
	}
	x := make(map[string]interface{})
	for i := 0; i < f; i++ {
		x[genString(10)] = genValue(((i+1)*n)/f - (i*n)/f)
	}
	return x
}

func MakeBasicGenEdit(G [][]string, c []float64) func(string, string) float64 {
	cost := func(A string, B string, pi int, d [][]float64) float64 {
		a := len(A) - len(G[pi][0])
		b := len(B) - len(G[pi][1])
		if a >= 0 && b >= 0 && A[a:] == G[pi][0] && B[b:] == G[pi][1] {
			return d[b][a] + c[pi]
		}
		return math.Inf(1)
	}

	return func(Ap string, Bp string) float64 {
		A := utf8.NewString(Ap)
		B := utf8.NewString(Bp)
		d := makeMatrix(B.RuneCount()+1, A.RuneCount()+1)

		for x := 0; x <= A.RuneCount(); x++ {
			for y := 0; y <= B.RuneCount(); y++ {
				if x == 0 && y == 0 {
					d[y][x] = 0
				} else {
					min := math.Inf(1)
					if x > 0 && y > 0 && A.At(x-1) == B.At(y-1) {
						min = d[y-1][x-1]
					}
					for pi, _ := range G {
						min = math.Fmin(min,
							cost(A.Slice(0, x),
								B.Slice(0, y),
								pi,
								d))
					}

					d[y][x] = min
				}
			}
		}

		return d[B.RuneCount()][A.RuneCount()]
	}
}

func RemoveServer(serv *server) os.Error {
	log.Printf("master: RemoveServer: server heap pre removal:\n%s\n", sHeap.printPresent())

	//Remove the Server
	sHeap.Remove(serv)
	log.Printf("master: RemoveServer: server heap post removal:\n%s\n", sHeap.printPresent())

	for i := 0; i < sHeap.vec.Len(); i++ {
		if sHeap.vec.At(i).(*server).id == serv.id {
			log.Printf("master: RemoveServer: remove didn't actually remove server %d! Busto Rhymes\n", serv.id)
			return nil
		}
	}
	str := fmt.Sprintf("%s:%d", serv.addr.IP.String(), serv.addr.Port)

	servers[serv.id] = &server{}, false
	addrToServerMap[str] = &server{}, false

	str1 := fmt.Sprintf("removing server %s:%d", serv.addr.IP.String(), serv.addr.Port)
	log.Printf("master: RemoveServer: begin %s\n", str1)

	network_size := float64(sHeap.vec.Len())
	if network_size <= 0 {
		return nil
	}
	//chunk_size := serv.chunks.Len()
	rep_factor := .9

	//map the size of the network to some fraction of that size to replicate to
	if network_size < 10 {
		rep_factor = .5
	} else {
		rep_factor = .3
	}

	rep_size := int(math.Fmin(math.Ceil(rep_factor*network_size), network_size))

	//for each chunk in the server, make a replication call
	sanity_threshhold1 := 4
	sanity_threshhold2 := 10
	sanity_count := 0

	targetServerMap := make(map[string](bool))

ChunkReplicate:
	for cnt := 0; cnt < serv.chunks.Len(); {

		var index int
		if sanity_count > sanity_threshhold1 {
			index = rand.Intn(rep_size)
		} else {
			index = rand.Intn(sHeap.vec.Len())
		}

		otherserver := sHeap.vec.At(index).(*server)
		chunk := serv.chunks.At(cnt).(*chunk)

		str := fmt.Sprintf("%s:%d", otherserver.addr.IP.String(), otherserver.addr.Port)

		sCnt := chunk.servers.Len()

		if sCnt >= len(servers) {
			log.Printf("master: RemoveServer: abort replication req for chunk %d; all active servers already hold replicas\n", chunk.chunkID)
			cnt++
			sanity_count = 0
			targetServerMap = make(map[string](bool))
		}

		if targetServerMap[str] == true {
			continue
		}

		for ijk := 0; ijk < sCnt; ijk++ {
			if chunk.servers.At(ijk).(*server) == otherserver {
				targetServerMap[str] = true

				if len(targetServerMap) >= len(servers) {
					log.Printf("master: RemoveServer: abort replication req for chunk %d; all active servers already hold replicas\n", chunk.chunkID)
					cnt++
					sanity_count = 0
					targetServerMap = make(map[string](bool))
				}

				continue ChunkReplicate
			}
		}

		log.Printf("master: RemoveServer: attempting to replicate chunk %d to server %s\n", chunk.chunkID, str)

		//log.Printf("master: RemoveServer: dialing %s to replicate\n", str)

		client, err := rpc.Dial("tcp", str)

		if err != nil {
			log.Printf("master: RemoveServer: unable to dial %s\n", str)
			sanity_count = sanity_count + 1
			continue
		} else {
			log.Printf("master: RemoveServer: dial %s succeeded\n", str)
		}
//.........这里部分代码省略.........

func resizeImage(src string) {
	fmt.Println(src)
	file, err := os.Open(src)
	if err != nil {
		panic(err.String())
	}
	defer file.Close()

	//img,format, err := image.Decode(file)
	i, err := jpeg.Decode(file)
	if err != nil {
		panic(err.String())
	}
	//fmt.Println(i)
	// Grab the image data
	/*var buf bytes.Buffer
	io.Copy(&buf, f)
	i, _, err := image.Decode(&buf)
	check(err)*/

	// Resize if too large, for more efficient moustachioing.
	// We aim for less than 1200 pixels in any dimension; if the
	// picture is larger than that, we squeeze it down to 600.
	const xmax, ymax = float64(900), float64(900)
	ratio := float64(1.0)

	b := i.Bounds()
	dx := float64(b.Dx())
	dy := float64(b.Dy())

	if dx > xmax {
		ratio = xmax / dx
	}
	if dy > ymax {
		ratio = math.Fmin(ymax/dy, ratio)
	}

	w := int(ratio * dx)
	h := int(ratio * dy)
	fmt.Println(ratio, w, h, dx, dy)
	i, _ = scale.Rescale(i, w, h)

	// Encode as a new JPEG image.
	var buf bytes.Buffer
	//buf.Reset()
	err = jpeg.Encode(&buf, i, nil)
	if err != nil {
		panic(err.String())
	}

	file2, err2 := os.Create(src + ".2.jpg")

	if err2 != nil {
		panic(err2.String())
	}

	file2.Write(buf.Bytes())

	defer file2.Close()

}

func col(v, maxv float64) uint8 {
	v = math.Log2(v / fill)
	v = v * 255 / maxv
	return uint8(math.Fmax(0, math.Fmin(255, v)))
}