Golang Ceil示例

说明

golang ceil示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: math

示例#1
文件: main.go 项目: yosisa/least

func (p *Pager) handleKeyEvent(ev termbox.Event) bool {
	p.width, p.height = termbox.Size()
	switch ev.Key {
	case termbox.KeyCtrlN, termbox.KeyArrowDown, termbox.KeyEnter:
		p.scrollDown(1)
	case termbox.KeyCtrlP, termbox.KeyArrowUp:
		p.scrollUp(1)
	case termbox.KeyCtrlU:
		p.scrollUp(int(math.Ceil(float64(p.height) / 2)))
	case termbox.KeyCtrlD:
		p.scrollDown(int(math.Ceil(float64(p.height) / 2)))
	case termbox.KeyCtrlF, termbox.KeySpace, termbox.KeyPgdn:
		p.scrollDown(max(0, p.height-3))
	case termbox.KeyCtrlB, termbox.KeyPgup:
		p.scrollUp(max(0, p.height-3))
	default:
		switch ev.Ch {
		case 'j':
			p.scrollDown(1)
		case 'k':
			p.scrollUp(1)
		case 'g':
			p.viewX = 0
		case 'G':
			p.viewX = max(0, len(p.lines)-p.height)
		case 'q':
			return false
		}
	}
	p.Redraw()
	return true
}

示例#2
文件: coreutils.go 项目: cgrates/cgrates

// Round return rounded version of x with prec precision.
//
// Special cases are:
//	Round(±0) = ±0
//	Round(±Inf) = ±Inf
//	Round(NaN) = NaN
func Round(x float64, prec int, method string) float64 {
	var rounder float64
	maxPrec := 7 // define a max precison to cut float errors
	if maxPrec < prec {
		maxPrec = prec
	}
	pow := math.Pow(10, float64(prec))
	intermed := x * pow
	_, frac := math.Modf(intermed)

	switch method {
	case ROUNDING_UP:
		if frac >= math.Pow10(-maxPrec) { // Max precision we go, rest is float chaos
			rounder = math.Ceil(intermed)
		} else {
			rounder = math.Floor(intermed)
		}
	case ROUNDING_DOWN:
		rounder = math.Floor(intermed)
	case ROUNDING_MIDDLE:
		if frac >= 0.5 {
			rounder = math.Ceil(intermed)
		} else {
			rounder = math.Floor(intermed)
		}
	default:
		rounder = intermed
	}

	return rounder / pow
}

示例#3
文件: Vector3.go 项目: uzudil/three.go

func (v3 *Vector3) Ceil() *Vector3 {
	v3.X = math.Ceil(v3.X)
	v3.Y = math.Ceil(v3.Y)
	v3.Z = math.Ceil(v3.Z)

	return v3
}

示例#4
文件: reg.go 项目: enodev0/rat

// GridScale determines what scale should be used on the graph, for
// both the X and Y axes
func (n *New) GridScale(column string, gridCount float64) float64 {
	xsort := make([]float64, len(n.Xvalues))
	ysort := make([]float64, len(n.Yvalues))
	copy(xsort, n.Xvalues)
	copy(ysort, n.Yvalues)
	sort.Float64s(xsort)
	sort.Float64s(ysort)
	// Courtesy: Stack Overflow
	microAdjust := func(span, grids float64) float64 {
		width := (span / (grids - 1))
		x := math.Ceil(math.Log10(width) - 1)
		p := math.Pow(10, x)
		rspace := math.Ceil(width/p) * p
		return rspace
	}

	switch column {
	case "X":
		rangeX := n.DataRange("X")
		return microAdjust(rangeX, gridCount)
	case "Y":
		rangeY := n.DataRange("Y")
		return microAdjust(rangeY, gridCount)
	default:
		return 0
	}
}

示例#5
文件: limiter_test.go 项目: wppurking/limiter

// TestLimiterRedis tests Limiter with Redis store.
func TestLimiterRedis(t *testing.T) {
	rate, err := NewRateFromFormatted("3-M")
	assert.Nil(t, err)

	store, err := NewRedisStoreWithOptions(
		newRedisPool(),
		StoreOptions{Prefix: "limitertests:redis", MaxRetry: 3})

	assert.Nil(t, err)

	limiter := NewLimiter(store, rate)

	i := 1
	for i <= 5 {
		ctx, err := limiter.Get("boo")
		assert.Nil(t, err)

		if i <= 3 {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.Equal(t, int64(3-i), ctx.Remaining)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)

		} else {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.True(t, ctx.Remaining == 0)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)
		}

		i++
	}
}

示例#6
文件: image.go 项目: cheggaaa/Anteater

func (i *Image) Crop(dst, format string, w, h, q int, optimize bool) error {
	cw, ch := w, h
	kc := float64(w) / float64(h)
	ki := float64(i.Width) / float64(i.Height)

	if ki > kc {
		ch = i.Height
		cw = int(math.Ceil(float64(i.Height) * kc))
	} else {
		cw = i.Width
		ch = int(math.Ceil(float64(i.Width) / kc))
	}

	crop := fmt.Sprintf("%dx%d+0+0", cw, ch)
	cmd := exec.Command("convert", i.Filename, "-gravity", "Center", "-crop", crop, dst)

	res, err := cmd.CombinedOutput()
	if err != nil {
		e := parseError(string(res))
		if e != "" {
			err = fmt.Errorf("%s", e)
		}
		return err
	}
	i.Filename = dst

	err = i.Resize(dst, format, w, h, q, optimize)
	if err != nil {
		return err
	}
	i.Width = w
	i.Height = h
	return nil
}

示例#7
文件: model.go 项目: LonelyPale/teg-workshop

func (g *group) updateBounds(move bool) {
	if g.model == nil {
		return
	}
	var w, h float64
	x0, y0, x1, y1 := detectBounds(g.model.Items())
	if !g.folded {
		w, h = (x1-x0)+2*GroupMargin, (y1-y0)+2*GroupMargin
		k := math.Ceil(w / GridDefaultGap)
		w = k * GridDefaultGap
		k = math.Ceil(h / GridDefaultGap)
		h = k * GridDefaultGap
	}
	fw, fh := g.getFoldedSize()
	if w < fw {
		w = fw
	}
	if h < fh {
		h = fh
	}
	if move {
		x, y := x0-GroupMargin, y0-GroupMargin
		g.Rect = geometry.NewRect(x, y, w, h)
	} else {
		g.Rect.Resize(w, h)
	}
}

示例#8
文件: cracking_eggs.go 项目: JeevFresno/codeeval

// If k == 2
// Solves d + (d - 1) + (d - 2) + (d - 3) + (d - 4) + ... + 1 = n
// This comes to d(d + 1) / 2 = n and then to
// d ** 2 + d - 2 * n = 0, so we solve this quadratic equoation to get d
// If k > 2, we check if it's large enough to do a binary search
//   If yes, we return the number of drops a binary search requires
//   If not, we use nFloors. d is the smalles number such that nFloors(d, k) >= n
func calcDrops(k, n int, cache *map[complex128]int) (d int) {
	need2binarySearch := int(math.Ceil(math.Log2(float64(n))))
	if k > need2binarySearch {
		return need2binarySearch
	}

	if k == 2 {
		//fmt.Println(">>>", k - 2, n, k)
		delta := 1 + 4*2*n
		floatD := (-1 + math.Sqrt(float64(delta))) / 2
		d = int(math.Ceil(floatD)) + (k - 2)
		return d
	}

	// If none the above, search for d such that nFloors(d, k) >= n
	//fmt.Println("Recurrence")
	d = 1
	for {
		nf := nFloors(d, k, cache)
		if nf >= n {
			return d
		}
		d += 1
	}
}

示例#9
文件: log.go 项目: leoliuzcl/skizze

/*
NewSketchForEpsilonDelta ...
*/
func NewSketchForEpsilonDelta(epsilon, delta float64) (*Sketch, error) {
	var (
		width = uint(math.Ceil(math.E / epsilon))
		depth = uint(math.Ceil(math.Log(1 / delta)))
	)
	return NewSketch(width, depth, true, 1.00026, true, true, 16)
}

示例#10
文件: geohash.go 项目: mmcloughlin/geohash

// Round returns a point inside the box, making an effort to round to minimal
// precision.
func (b Box) Round() (lat, lng float64) {
	x := maxDecimalPower(b.MaxLat - b.MinLat)
	lat = math.Ceil(b.MinLat/x) * x
	x = maxDecimalPower(b.MaxLng - b.MinLng)
	lng = math.Ceil(b.MinLng/x) * x
	return
}

示例#11
文件: thumbfile.go 项目: rizzles/convert

func (this *ThumbFile) ComputeCrop(original *UploadedFile) (int, int, error) {
	re := regexp.MustCompile("(.*):(.*)")
	matches := re.FindStringSubmatch(this.CropRatio)
	if len(matches) != 3 {
		return 0, 0, errors.New("Invalid crop_ratio")
	}

	wRatio, werr := strconv.ParseFloat(matches[1], 64)
	hRatio, herr := strconv.ParseFloat(matches[2], 64)
	if werr != nil || herr != nil {
		return 0, 0, errors.New("Invalid crop_ratio")
	}

	var cropWidth, cropHeight float64

	if wRatio >= hRatio {
		wRatio = wRatio / hRatio
		hRatio = 1
		cropWidth = math.Ceil(float64(this.ComputeHeight(original)) * wRatio)
		cropHeight = math.Ceil(float64(this.ComputeHeight(original)) * hRatio)
	} else {
		hRatio = hRatio / wRatio
		wRatio = 1
		cropWidth = math.Ceil(float64(this.ComputeWidth(original)) * wRatio)
		cropHeight = math.Ceil(float64(this.ComputeWidth(original)) * hRatio)
	}

	return int(cropWidth), int(cropHeight), nil
}

示例#12
文件: rankdirectory.go 项目: siongui/go-succinct-data-structure-trie

/**
  Used to build a rank directory from the given input string.

  @param data A javascript string containing the data, as readable using the
  BitString object.

  @param numBits The number of bits to index.

  @param l1Size The number of bits that each entry in the Level 1 table
  summarizes. This should be a multiple of l2Size.

  @param l2Size The number of bits that each entry in the Level 2 table
  summarizes.
*/
func CreateRankDirectory(data string, numBits, l1Size, l2Size uint) RankDirectory {
	bits := BitString{}
	bits.Init(data)
	var p, i uint = 0, 0
	var count1, count2 uint = 0, 0
	l1bits := uint(math.Ceil(math.Log2(float64(numBits))))
	l2bits := uint(math.Ceil(math.Log2(float64(l1Size))))

	directory := BitWriter{}

	for p+l2Size <= numBits {
		count2 += bits.Count(p, l2Size)
		i += l2Size
		p += l2Size
		if i == l1Size {
			count1 += count2
			directory.Write(count1, l1bits)
			count2 = 0
			i = 0
		} else {
			directory.Write(count2, l2bits)
		}
	}

	rd := RankDirectory{}
	rd.Init(directory.GetData(), data, numBits, l1Size, l2Size)
	return rd
}

示例#13
文件: png_controller.go 项目: rchargel/zilch

func (c PngController) drawDistribution(img *image.RGBA, lat, lng, scale float32, zipCodes int) {
	y := int((180 - (lat + 90)) * scale)
	x := int((lng + 180) * scale)
	p := image.Rect(x, y, x+int(math.Ceil(float64(scale))), y+int(math.Ceil(float64(scale))))

	var zipColor color.RGBA
	if zipCodes > 1000 {
		zipColor = color.RGBA{255, 0, 0, 255}
	} else if zipCodes > 800 {
		zipColor = color.RGBA{255, 87, 0, 255}
	} else if zipCodes > 600 {
		zipColor = color.RGBA{255, 153, 0, 255}
	} else if zipCodes > 400 {
		zipColor = color.RGBA{255, 204, 51, 255}
	} else if zipCodes > 200 {
		zipColor = color.RGBA{255, 255, 102, 255}
	} else if zipCodes > 100 {
		zipColor = color.RGBA{153, 255, 153, 255}
	} else if zipCodes > 50 {
		zipColor = color.RGBA{255, 255, 255, 255}
	} else {
		zipColor = color.RGBA{204, 204, 204, 255}
	}
	draw.Draw(img, p, &image.Uniform{zipColor}, image.ZP, draw.Src)
}

示例#14
文件: euler_problem_1.go 项目: phoenix-opensource-marathon/project-euler

func main() {
	var N, N1, N2, N3, i, sum float64
	N = 1000
	N1 = math.Ceil(N / 3.0)
	N2 = math.Ceil(N / 5.0)
	N3 = math.Ceil(N / 15.0)
	sum = 0
	i = 1
	for i < N1 {
		sum += 3 * i
		i++
	}
	i = 1
	for i < N2 {
		sum += 5 * i
		i++
	}
	// Subtracting double counted numbers (multiples of 15)
	i = 1
	for i < N3 {
		sum -= 15 * i
		i++
	}
	fmt.Println(sum)
}

示例#15
文件: limiter_test.go 项目: ulule/limiter

func testLimiter(t *testing.T, store Store, rate Rate) {
	limiter := NewLimiter(store, rate)

	i := 1
	for i <= 5 {
		if i <= 3 {
			ctx, err := limiter.Peek("boo")
			assert.NoError(t, err)
			assert.Equal(t, int64(3-(i-1)), ctx.Remaining)
		}

		ctx, err := limiter.Get("boo")
		assert.NoError(t, err)

		if i <= 3 {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.Equal(t, int64(3-i), ctx.Remaining)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)
			ctx, err := limiter.Peek("boo")
			assert.NoError(t, err)
			assert.Equal(t, int64(3-i), ctx.Remaining)
		} else {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.True(t, ctx.Remaining == 0)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)
		}

		i++
	}

}

示例#16
文件: sig.go 项目: rakoo/rproxy

// Get the size of the blocks depending on input size
// We don't want signature much larger than 1024B
func getBlockSize(inputsize uint64) uint32 {
	// Substract version and block size in available size
	maxSize := MAX_SIG_SIZE - 4 - 4

	maxBlocks := math.Ceil(float64(maxSize) / float64(ROLLSUM_SIZE+sha1.Size))
	return uint32(math.Ceil(float64(inputsize) / maxBlocks))
}

示例#17
文件: client.go 项目: Ingensi/dockerbeat

// Increase window size by factor 1.5 until max window size
// (window size grows exponentially)
// TODO: use duration until ACK to estimate an ok max window size value
func (l *lumberjackClient) tryGrowWindowSize(batchSize int) {
	if l.windowSize <= batchSize {
		if l.maxOkWindowSize < l.windowSize {
			logp.Debug("logstash", "update max ok window size: %v < %v", l.maxOkWindowSize, l.windowSize)
			l.maxOkWindowSize = l.windowSize

			newWindowSize := int(math.Ceil(1.5 * float64(l.windowSize)))
			logp.Debug("logstash", "increase window size to: %v", newWindowSize)

			if l.windowSize <= batchSize && batchSize < newWindowSize {
				logp.Debug("logstash", "set to batchSize: %v", batchSize)
				newWindowSize = batchSize
			}
			if newWindowSize > l.maxWindowSize {
				logp.Debug("logstash", "set to max window size: %v", l.maxWindowSize)
				newWindowSize = l.maxWindowSize
			}
			l.windowSize = newWindowSize
		} else if l.windowSize < l.maxOkWindowSize {
			logp.Debug("logstash", "update current window size: %v", l.windowSize)

			l.windowSize = int(math.Ceil(1.5 * float64(l.windowSize)))
			if l.windowSize > l.maxOkWindowSize {
				logp.Debug("logstash", "set to max ok window size: %v", l.maxOkWindowSize)
				l.windowSize = l.maxOkWindowSize
			}
		}
	}
}

示例#18
文件: item_test.go 项目: karlseguin/ccache

func (_ *ItemTests) TTL() {
	now := time.Now().UnixNano()
	item1 := &Item{expires: now + int64(time.Second)}
	item2 := &Item{expires: now - int64(time.Second)}
	Expect(int(math.Ceil(item1.TTL().Seconds()))).To.Equal(1)
	Expect(int(math.Ceil(item2.TTL().Seconds()))).To.Equal(-1)
}

示例#19
文件: estimator.go 项目: kubernetes/contrib

// Estimate estimates the number needed of nodes of the given shape.
func (basicEstimator *BasicNodeEstimator) Estimate(node *apiv1.Node) (int, string) {
	var buffer bytes.Buffer
	buffer.WriteString("Needed nodes according to:\n")
	result := 0
	if cpuCapcaity, ok := node.Status.Capacity[apiv1.ResourceCPU]; ok {
		prop := int(math.Ceil(float64(basicEstimator.cpuSum.MilliValue()) / float64(cpuCapcaity.MilliValue())))
		buffer.WriteString(fmt.Sprintf("CPU: %d\n", prop))
		result = maxInt(result, prop)
	}
	if memCapcaity, ok := node.Status.Capacity[apiv1.ResourceMemory]; ok {
		prop := int(math.Ceil(float64(basicEstimator.memorySum.Value()) / float64(memCapcaity.Value())))
		buffer.WriteString(fmt.Sprintf("Mem: %d\n", prop))
		result = maxInt(result, prop)
	}
	if podCapcaity, ok := node.Status.Capacity[apiv1.ResourcePods]; ok {
		prop := int(math.Ceil(float64(basicEstimator.GetCount()) / float64(podCapcaity.Value())))
		buffer.WriteString(fmt.Sprintf("Pods: %d\n", prop))
		result = maxInt(result, prop)
	}
	for port, count := range basicEstimator.portSum {
		buffer.WriteString(fmt.Sprintf("Port %d: %d\n", port, count))
		result = maxInt(result, count)
	}
	return result, buffer.String()
}

示例#20
文件: face.go 项目: berak/go-faces

// as reference, this is similar to the opencv one
// Sampler
func elbp(m *Matrix, pos, radius int) (way uint8) {
	way = 0
	cen := m.e[pos]
	for n := uint8(0); n < 8; n++ {
		x := float64(-radius) * math.Sin(math.Pi*float64(n)/4.0)
		y := float64(radius) * math.Cos(math.Pi*float64(n)/4.0)
		fx := math.Floor(x)
		fy := math.Floor(y)
		cx := math.Ceil(x)
		cy := math.Ceil(y)
		// fractional part
		ty := y - fy
		tx := x - fx
		// set interpolation weights
		w1 := (1.0 - tx) * (1.0 - ty)
		w2 := tx * (1.0 - ty)
		w3 := (1.0 - tx) * ty
		w4 := tx * ty
		t := w1 * float64(m.e[pos+int(fx)+int(fy)*m.w])
		t += w2 * float64(m.e[pos+int(cx)+int(fy)*m.w])
		t += w3 * float64(m.e[pos+int(fx)+int(cy)*m.w])
		t += w4 * float64(m.e[pos+int(cx)+int(cy)*m.w])
		if uint8(t) > cen {
			way |= 1 << n
		}
	}
	return
}

示例#21
文件: window.go 项目: ChongFeng/beats

// Increase window size by factor 1.5 until max window size
// (window size grows exponentially)
// TODO: use duration until ACK to estimate an ok max window size value
func (w *window) tryGrowWindow(batchSize int) {
	windowSize := w.get()

	if windowSize <= batchSize {
		if w.maxOkWindowSize < windowSize {
			debug("update max ok window size: %v < %v",
				w.maxOkWindowSize, w.windowSize)
			w.maxOkWindowSize = windowSize

			newWindowSize := int(math.Ceil(1.5 * float64(windowSize)))
			debug("increase window size to: %v", newWindowSize)

			if windowSize <= batchSize && batchSize < newWindowSize {
				debug("set to batchSize: %v", batchSize)
				newWindowSize = batchSize
			}
			if newWindowSize > w.maxWindowSize {
				debug("set to max window size: %v", w.maxWindowSize)
				newWindowSize = int(w.maxWindowSize)
			}

			windowSize = newWindowSize
		} else if windowSize < w.maxOkWindowSize {
			debug("update current window size: %v", w.windowSize)

			windowSize = int(math.Ceil(1.5 * float64(windowSize)))
			if windowSize > w.maxOkWindowSize {
				debug("set to max ok window size: %v", w.maxOkWindowSize)
				windowSize = w.maxOkWindowSize
			}
		}

		atomic.StoreInt32(&w.windowSize, int32(windowSize))
	}
}

示例#22
文件: game_engine.go 项目: bootstrap108/mars-challenge

func (game *GameInfo) handleTeam(team *Team, wg *sync.WaitGroup) {
	var temperatureRatio float64
	var radiationRatio float64
	var energyGain float64
	var energyLoss float64
	var lifeLoss float64

	for team.Life > 0 && game.Running {
		time.Sleep(1 * time.Second)
		radiationRatio = (float64)(game.Reading.Radiation-minRadiation) / (float64)(maxRadiation-minRadiation)
		energyLoss = radiationRatio * maxEnergyLoss
		if float64(team.Energy)-energyLoss <= 0 {
			team.Shield = false
		}

		if team.Shield {
			team.Energy = int64(math.Max(float64(team.Energy)-math.Ceil(energyLoss), 0))
			log.Printf("Team %s: Energy -%.2f\n", team.Name, energyLoss)
			continue
		}

		radiationRatio = (float64)(game.Reading.Radiation-minRadiation) / (float64)(maxRadiation-minRadiation)
		lifeLoss = radiationRatio * maxLifeLoss
		team.Life = int64(math.Max(float64(team.Life)-math.Ceil(lifeLoss), 0))

		temperatureRatio = (game.Reading.Temperature - minTemperature) / (maxTemperature - minTemperature)
		energyGain = temperatureRatio * maxEnergyGain
		team.Energy = int64(math.Min(float64(team.Energy)+math.Ceil(energyGain), 100))

		log.Printf("Team %s: Life -%.2f, Energy +%.2f\n", team.Name, lifeLoss, energyGain)
	}

	log.Println("Exiting goroutine for team", team.Name)
	wg.Done()
}

示例#23
文件: limiter_test.go 项目: wppurking/limiter

// TestLimiterMemory tests Limiter with memory store.
func TestLimiterMemory(t *testing.T) {
	rate, err := NewRateFromFormatted("3-M")
	assert.Nil(t, err)

	store := NewMemoryStoreWithOptions(StoreOptions{
		Prefix:          "limitertests:memory",
		CleanUpInterval: 30 * time.Second,
	})

	limiter := NewLimiter(store, rate)

	i := 1
	for i <= 5 {
		ctx, err := limiter.Get("boo")
		assert.Nil(t, err)

		if i <= 3 {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.Equal(t, int64(3-i), ctx.Remaining)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)
		} else {
			assert.Equal(t, int64(3), ctx.Limit)
			assert.True(t, ctx.Remaining == 0)
			assert.True(t, math.Ceil(time.Since(time.Unix(ctx.Reset, 0)).Seconds()) <= 60)
		}

		i++
	}
}

示例#24
文件: clients.go 项目: dantoye/bots

func (e *Entity) Colliding() bool {
	playerSize := .5
	sx := int(math.Floor(e.x - playerSize/2))
	sy := int(math.Floor(e.y - playerSize/2))
	sz := int(math.Floor(e.z - playerSize/2))
	lx := int(math.Ceil(e.x + playerSize/2))
	ly := int(math.Ceil(e.y + playerSize/2))
	lz := int(math.Ceil(e.z + playerSize/2))
	if sx < 0 || lx >= worldW || sz < 0 || lz >= worldD {
		return true
	}
	if sy < 0 || ly >= worldH {
		return false
	}
	for ix := sx; ix < lx; ix += 1 {
		for iy := sy; iy < ly; iy += 1 {
			for iz := sz; iz < lz; iz += 1 {
				blockType := level[ix][iy][iz]
				if blockType > 0 {
					return true
				}
			}
		}
	}
	return false
}

示例#25
文件: misc.go 项目: mabetle/mcore

// Round(3.1556,2)=3.16
// Round(3.1556,0)=3
func Round(val float64, places int) float64 {
	var t float64
	f := math.Pow10(places)
	x := val * f
	if math.IsInf(x, 0) || math.IsNaN(x) {
		return val
	}
	if x >= 0.0 {
		t = math.Ceil(x)
		if (t - x) > 0.50000000001 {
			t -= 1.0
		}
	} else {
		t = math.Ceil(-x)
		if (t + x) > 0.50000000001 {
			t -= 1.0
		}
		t = -t
	}
	x = t / f

	if !math.IsInf(x, 0) {
		return x
	}
	return t
}

示例#26
文件: resize.go 项目: train860/picfit

func precomputeWeights(dstSize, srcSize int, filter ResampleFilter) []pweights {
	du := float64(srcSize) / float64(dstSize)
	scale := du
	if scale < 1.0 {
		scale = 1.0
	}
	ru := math.Ceil(scale * filter.Support)

	out := make([]pweights, dstSize)

	for v := 0; v < dstSize; v++ {
		fu := (float64(v)+0.5)*du - 0.5

		startu := int(math.Ceil(fu - ru))
		if startu < 0 {
			startu = 0
		}
		endu := int(math.Floor(fu + ru))
		if endu > srcSize-1 {
			endu = srcSize - 1
		}

		wsum := int32(0)
		for u := startu; u <= endu; u++ {
			w := int32(0xff * filter.Kernel((float64(u)-fu)/scale))
			if w != 0 {
				wsum += w
				out[v].iwpairs = append(out[v].iwpairs, iwpair{u, w})
			}
		}
		out[v].wsum = wsum
	}

	return out
}

示例#27
文件: color.go 项目: essentialkaos/ek

// RGB2HSB convert RGB color to HSB (HSV)
func RGB2HSB(r, g, b int) (int, int, int) {
	if r+g+b == 0 {
		return 0, 0, 0
	}

	max := mathutil.Max(mathutil.Max(r, g), b)
	min := mathutil.Min(mathutil.Min(r, g), b)

	var (
		h     int
		s, bb float64
	)

	switch max {
	case min:
		h = 0
	case r:
		h = (60*(g-b)/(max-min) + 360) % 360
	case g:
		h = (60*(b-r)/(max-min) + 120)
	case b:
		h = (60*(r-g)/(max-min) + 240)
	}

	bb = math.Ceil((float64(max) / 255.0) * 100.0)

	if max != 0 {
		fmax, fmin := float64(max), float64(min)
		s = math.Ceil(((fmax - fmin) / fmax) * 100.0)
	}

	return h, int(s), int(bb)
}

示例#28
文件: entity.go 项目: Thinkofname/monstergame

func CheckCollision(pb *box, dx, dy float64) (col bool, nx, ny float64) {
	for x := int(math.Floor(pb.x/tileSize) - 1); x <= int(math.Ceil((pb.x+pb.w)/tileSize)+1); x++ {
		for y := int(math.Floor(pb.y/tileSize) - 1); y <= int(math.Ceil((pb.y+pb.h)/tileSize)+1); y++ {
			t := GetTile(x, y)
			if t.IsSolid() {
				b := &box{
					x: float64(x) * tileSize,
					y: float64(y) * tileSize,
					w: tileSize, h: tileSize,
				}
				if b.collides(pb) {
					col = true
					if dx < 0 {
						nx = b.x + b.w + 0.001
					} else if dx > 0 {
						nx = b.x - pb.w - 0.001
					}
					if dy < 0 {
						ny = b.y + b.h + 0.001
					} else if dy > 0 {
						ny = b.y - pb.h - 0.001
					}
					nx /= tileSize
					ny /= tileSize
					return
				}
			}
		}
	}
	return
}

示例#29
文件: density.go 项目: hongbin/kubernetes

func extractLatencyMetrics(latencies []podLatencyData) LatencyMetric {
	length := len(latencies)
	perc50 := latencies[int(math.Ceil(float64(length*50)/100))-1].Latency
	perc90 := latencies[int(math.Ceil(float64(length*90)/100))-1].Latency
	perc99 := latencies[int(math.Ceil(float64(length*99)/100))-1].Latency
	return LatencyMetric{Perc50: perc50, Perc90: perc90, Perc99: perc99}
}

示例#30
文件: mapwidget.go 项目: kch42/biomed

func (mw *MapWidget) updateChunkBounds() {
	startX := int(math.Floor(float64(mw.offX) / tileSize))
	startZ := int(math.Floor(float64(mw.offZ) / tileSize))
	endX := int(math.Ceil(float64(mw.offX+mw.w) / tileSize))
	endZ := int(math.Ceil(float64(mw.offZ+mw.h) / tileSize))
	mw.regWrap.SetChunkBounds(startX, startZ, endX, endZ)
}

展开阅读全文