Example #1
0
func TestEarth2(t *testing.T) {
	// p. 274
	v, err := pp.LoadPlanet(pp.Earth)
	if err != nil {
		t.Fatal(err)
	}
	for _, d := range ep {
		yf := float64(d.y) + (float64(d.m)-.5)/12
		u, r := pa.Perihelion2(pa.Earth, yf, .0004, v)
		y, m, df := julian.JDToCalendar(u)
		dd, f := math.Modf(df)
		if y != d.y || m != d.m || int(dd) != d.d ||
			math.Abs(f*24-d.h) > .01 ||
			math.Abs(r-d.r) > .000001 {
			t.Log(d)
			t.Fatal(y, m, int(dd), f*24, r)
		}
	}
	for _, d := range ea {
		yf := float64(d.y) + (float64(d.m)-.5)/12
		u, r := pa.Aphelion2(pa.Earth, yf, .0004, v)
		y, m, df := julian.JDToCalendar(u)
		dd, f := math.Modf(df)
		if y != d.y || m != d.m || int(dd) != d.d ||
			math.Abs(f*24-d.h) > .01 ||
			math.Abs(r-d.r) > .000001 {
			t.Log(d)
			t.Fatal(y, m, int(dd), f*24, r)
		}
	}
}
Example #2
0
File: nzmap.go Project: GeoNet/mtr
/*
Medium returns a map of New Zealand at medium resolution.  The underlying longitude latitude grid is in 0.1
increments.  Linear interpolation is used between grid points to estimate the location of each Point on the map.
*/
func (pts Points) Medium(b *bytes.Buffer) {
	b.WriteString(nzMedium)

	// the long/lat grid is accurate to 0.1 degree below that use a linear approximation between
	// the grid values.  This removes liniations in the plot
	var p, pp pt
	for i, v := range pts {
		if v.Longitude < 0 {
			v.Longitude = v.Longitude + 360.0
		}
		xi, xf := math.Modf(v.Longitude*10 - 1650.0)
		x := int(xi)
		yi, yf := math.Modf(v.Latitude*10 + 480.0)
		y := int(yi)

		if x >= 0 && x <= 150 && y >= 0 && y <= 140 {
			p = nzMediumPts[int(x)][y]
			pp = nzMediumPts[x+1][y+1]
			pts[i].x = p.x + int(float64(pp.x-p.x)*xf)
			pts[i].y = p.y + int(float64(pp.y-p.y)*yf)
			pts[i].visible = true
		} else {
			pts[i].x = -1000
			pts[i].y = -1000
		}

	}
	return
}
Example #3
0
func (g *stereoSine) processAudio(out [][]float32) {
	for i := range out[0] {
		val1 := g.volume * math.Sin(2*math.Pi*g.phase1)
		val2 := g.volume * math.Sin(2*math.Pi*g.phase2)

		val1l := math.Max(val1*g.pan1, 0) * 0.5
		val2l := math.Max(val2*g.pan2, 0) * 0.5

		val1r := math.Max(val1*-g.pan1, 0) * 0.5
		val2r := math.Max(val2*-g.pan2, 0) * 0.5

		out[0][i] = float32(val1l + val2l)
		out[1][i] = float32(val1r + val2r)

		_, g.phase1 = math.Modf(g.phase1 + g.step1)
		_, g.phase2 = math.Modf(g.phase2 + g.step2)

		g.volume += g.fade
		if g.volume < 0 {
			g.volume = 0
			g.fade = 0
			g.control <- true
		}
		if g.volume > 1 {
			g.volume = 1
			g.fade = 0
			g.control <- true
		}
	}
}
Example #4
0
func generateRandomNetwork(address *net.IPNet) string {
	tick := float64(time.Now().UnixNano() / 1000000)

	ones, bits := address.Mask.Size()
	zeros := bits - ones
	uniqIPsAmount := math.Pow(2.0, float64(zeros))

	rawIP := math.Mod(tick, uniqIPsAmount)

	remainder := rawIP

	remainder, octet4 := math.Modf(remainder / 255.0)
	remainder, octet3 := math.Modf(remainder / 255.0)
	remainder, octet2 := math.Modf(remainder / 255.0)

	base := address.IP

	address.IP = net.IPv4(
		byte(remainder)|base[0],
		byte(octet2*255)|base[1],
		byte(octet3*255)|base[2],
		byte(octet4*255)|base[3],
	)

	address.IP.Mask(address.Mask)

	return address.String()
}
Example #5
0
func LatLongToString(pc *PolarCoord, format LatLongFormat) (string, string) {

	var lat, long, latrem, longrem, latmin, longmin, latsec, longsec float64
	var latitude, longitude string

	switch format {
	case LLFdeg:
		latitude = f64toa(pc.Latitude, 6)
		longitude = f64toa(pc.Longitude, 6)

	case LLFdms:
		lat, latrem = math.Modf(pc.Latitude)

		if lat < 0 {
			lat *= -1
			latrem *= -1
		}

		long, longrem = math.Modf(pc.Longitude)
		if long < 0 {
			long *= -1
			longrem *= -1
		}

		latmin, latrem = math.Modf(latrem / 100 * 6000)
		longmin, longrem = math.Modf(longrem / 100 * 6000)

		latsec = latrem / 100 * 6000
		longsec = longrem / 100 * 6000

		if pc.Latitude < 0 {
			latitude = "S "

		} else {
			latitude = "N "
		}
		latitude += fmt.Sprintf("%d°", int(lat))
		if latmin != 0.0 || latsec != 0.0 {
			latitude += fmt.Sprintf("%d'", int(latmin))
		}
		if latsec != 0.0 {
			latitude += fmt.Sprintf("%s''", f64toa(latsec, 2))
		}

		if pc.Longitude < 0 {
			longitude = "W "
		} else {
			longitude = "E "
		}
		longitude += fmt.Sprintf("%d°", int(long))
		if longmin != 0.0 || longsec != 0.0 {
			longitude += fmt.Sprintf("%d'", int(longmin))
		}
		if longsec != 0.0 {
			longitude += fmt.Sprintf("%s''", f64toa(longsec, 2))
		}
	}
	return latitude, longitude
}
Example #6
0
// ProcessAudio processes the audio
func (sine *Sine) ProcessAudio(out [][2]float32) {
	for i := range out {
		out[i][0] = float32(math.Sin(2 * math.Pi * sine.phaseL))
		_, sine.phaseL = math.Modf(sine.phaseL + sine.stepL)
		out[i][1] = float32(math.Sin(2 * math.Pi * sine.phaseR))
		_, sine.phaseR = math.Modf(sine.phaseR + sine.stepR)
	}
}
Example #7
0
func (g *stereoSine) processAudio(out [][]float32) {
	for i := range out[0] {
		out[0][i] = float32(math.Sin(2 * math.Pi * g.phaseL))
		_, g.phaseL = math.Modf(g.phaseL + g.stepL)
		out[1][i] = float32(math.Sin(2 * math.Pi * g.phaseR))
		_, g.phaseR = math.Modf(g.phaseR + g.stepR)
	}
}
Example #8
0
func GetChunkCoords(x float32, y float32) (float32, float32) {
	chunkSize := float64(100)

	xRoot, _ := math.Modf(float64(x) / chunkSize)
	yRoot, _ := math.Modf(float64(y) / chunkSize)

	return float32(xRoot * chunkSize), float32(yRoot * chunkSize)
}
Example #9
0
File: date.go Project: sywxf/xls
func julianDateToGregorianTime(part1, part2 float64) time.Time {
	part1I, part1F := math.Modf(part1)
	part2I, part2F := math.Modf(part2)
	julianDays := part1I + part2I
	julianFraction := part1F + part2F
	julianDays, julianFraction = shiftJulianToNoon(julianDays, julianFraction)
	day, month, year := doTheFliegelAndVanFlandernAlgorithm(int(julianDays))
	hours, minutes, seconds, nanoseconds := fractionOfADay(julianFraction)
	return time.Date(year, time.Month(month), day, hours, minutes, seconds, nanoseconds, time.UTC)
}
Example #10
0
// durationToSQL converts a time.Duration to ISO standard SQL syntax,
// e.g. "1 2:3:4" for one day, two hours, three minutes, and four seconds.
func durationToSQL(d time.Duration) []byte {
	dSeconds := d.Seconds()
	dMinutes, fSeconds := math.Modf(dSeconds / 60)
	seconds := fSeconds * 60
	dHours, fMinutes := math.Modf(dMinutes / 60)
	minutes := fMinutes * 60
	days, fHours := math.Modf(dHours / 24)
	hours := fHours * 24
	sql := fmt.Sprintf("%.0f %.0f:%.0f:%f", days, hours, minutes, seconds)
	return []byte(sql)
}
Example #11
0
func (g *stereoSine) processAudio(out [][]float32) {
	var t float64 = 0
	for i := range out[0] {
		out[0][i] = float32(math.Sin(2*math.Pi*g.phaseL*(t/float64(bpm)))) / 2
		//out[0][i] = float32(math.Sin(2 * math.Pi * float64(tcp%400) * (t / float64(bpm))))
		_, g.phaseL = math.Modf(g.phaseL + g.stepL)
		out[1][i] = float32(math.Sin(2*math.Pi*g.phaseR*(t/float64(bpm)))) / 2
		//out[1][i] = float32(math.Sin(2 * math.Pi * float64(tcp%400) * (t / float64(bpm))))
		_, g.phaseR = math.Modf(g.phaseR + g.stepR)
		t++
	}
}
Example #12
0
// NumberFormat convert float or int to string (like PHP number_format() )
// in local format, for example:
//	NumberFormat( 123456.12, 4, ",", " " )
//	>> 123 456,1200
//
// Special cases are:
//	NumberFormat(±Inf) = formatted 0.0
//	NumberFormat(NaN) = formatted 0.0
func NumberFormat(number float64, decimals int, decPoint, thousandsSep string) string {
	if math.IsNaN(number) || math.IsInf(number, 0) {
		number = 0
	}

	var ret string
	var negative bool

	if number < 0 {
		number *= -1
		negative = true
	}

	d, fract := math.Modf(number)

	if decimals <= 0 {
		fract = 0
	} else {
		pow := math.Pow(10, float64(decimals))
		fract = RoundPrec(fract*pow, 0)
	}

	if thousandsSep == "" {
		ret = strconv.FormatFloat(d, 'f', 0, 64)
	} else if d >= 1 {
		var x float64
		for d >= 1 {
			d, x = math.Modf(d / 1000)
			x = x * 1000
			ret = strconv.FormatFloat(x, 'f', 0, 64) + ret
			if d >= 1 {
				ret = thousandsSep + ret
			}
		}
	} else {
		ret = "0"
	}

	fracts := strconv.FormatFloat(fract, 'f', 0, 64)

	// "0" pad left
	for i := len(fracts); i < decimals; i++ {
		fracts = "0" + fracts
	}

	ret += decPoint + fracts

	if negative {
		ret = "-" + ret
	}
	return ret
}
Example #13
0
//	范围随机数 float64
//	只随机精度的值,随机精度范围[0.x... -- 0.x...]
func RandBetweenFloat(s, n float64) float64 {
	if s > n {
		s, n = n, s
	}
	_, sFrac := math.Modf(s)
	_, nFrac := math.Modf(n)

	mathrand.Seed(time.Now().UnixNano())

	rf := float64(mathrand.Int63()) / (1 << 63)
	rf = sFrac + rf*(nFrac-sFrac)

	return rf
}
Example #14
0
func (me *renderTile) CastRay(x, y int, col *color.RGBA) {
	me.fx, me.fy = float64(x), float64(y)
	col.R, col.G, col.B, col.A = 0, 0, 0, 0
	me.rayPos.X, me.rayPos.Y, me.rayPos.Z = ((me.fx / width) - 0.5), ((me.fy / height) - 0.5), 0
	me.rayPos.MultMat(cmat1)
	me.rayTmp.X, me.rayTmp.Y, me.rayTmp.Z = 0, 0, planeDist
	me.rayTmp.MultMat(cmat1)
	// if (CamRot.Y != 0) && ((x == 0) || (x == 39) || (x == 79) || (x == 119) || (x == 159)) && ((y == 0) || (y == 44) || (y == 89)) { log.Printf("[%v,%v] 0,0,%v ==> %+v (for %+v)", x, y, planeDist, me.rayTmp, me.rayDir) }
	me.rayDir.X, me.rayDir.Y, me.rayDir.Z = me.rayPos.X, me.rayPos.Y, me.rayPos.Z-me.rayTmp.Z
	me.rayDir.Normalize()
	me.rayDir.MultMat(pmat)
	me.rayPos.Add(CamPos)

	// me.rayDir.X, me.rayDir.Y, me.rayDir.Z = -((me.fx / width) - 0.5), -((me.fy / height) - 0.5), planeDist

	if true {
		// if ((x == 0) || (x == 159)) && ((y == 0) || (y == 89)) { log.Printf("RAYPOS[%v,%v]=%+v", x, y, me.rayPos) }
		me.numSteps = 0
		for (col.A < 255) && me.rayPos.AllInRange(vmin, vmax) && (me.numSteps <= (vboth)) {
			me.numSteps++
			if me.rayPos.AllInRange(0, fs) {
				if col.A == 0 {
					if (int(me.rayPos.X) == 0) || (int(me.rayPos.X) == (SceneSize - 1)) {
						col.R, col.G, col.B, col.A = 0, 0, 64, 64
					} else if (int(me.rayPos.Y) == 0) || (int(me.rayPos.Y) == (SceneSize - 1)) {
						col.R, col.G, col.B, col.A = 0, 64, 0, 64
					} else {
						col.R, col.G, col.B, col.A = 32, 32, 32, 48
					}
				}
				if samples {
					_, me.fracx = math.Modf(me.rayPos.X)
					_, me.fracy = math.Modf(me.rayPos.Y)
					_, me.fracz = math.Modf(me.rayPos.Z)
					me.rayIntX, me.rayIntY, me.rayIntZ = int(me.rayPos.X), int(me.rayPos.Y), int(me.rayPos.Z)
					me.lrayIntX, me.lrayIntY, me.lrayIntZ = int(me.rayPos.X+1), int(me.rayPos.Y+1), int(me.rayPos.Z+1)
					me.getSample(me.rayIntX, me.rayIntY, me.rayIntZ, col)
					me.getSample(me.lrayIntX, me.rayIntY, me.rayIntZ, &me.colx)
					me.getSample(me.rayIntX, me.lrayIntY, me.rayIntZ, &me.coly)
					me.getSample(me.rayIntX, me.rayIntY, me.lrayIntZ, &me.colz)
					//me.mixAll()
				} else {
					me.rayIntX, me.rayIntY, me.rayIntZ = int(me.rayPos.X), int(me.rayPos.Y), int(me.rayPos.Z)
					me.getSample(me.rayIntX, me.rayIntY, me.rayIntZ, col)
				}
			}
			me.rayPos.Add(me.rayDir)
		}
	}
}
Example #15
0
func preComputeFilter(scale float64,
	outSize, srcSize int,
	scaleBpp float64) []filter {

	ret := make([]filter, outSize)

	// The minimum worthwhile fraction of a pixel. This value is also used
	// to avoid direct floating-point comparisons; instead of comparing two
	// values for equality, we test if their difference is smaller than this
	// value.
	const minFrac = 1.0 / 256.0

	for i := 0; i < outSize; i++ {
		// compute the address and first weight
		addr, invw := math.Modf(float64(i) * scale)
		ret[i].idx = int(addr)
		frstw := 1.0 - invw
		if frstw < minFrac {
			ret[i].idx++
			frstw = 0.0
		} else {
			ret[i].n = 1
		}
		// compute the number of pixels
		count, frac := math.Modf(scale - frstw)
		ret[i].n = ret[i].n + int(count)
		if frac >= minFrac {
			ret[i].n++
		} else {
			frac = 0.0
		}
		// allocate the slice of weights
		ret[i].weights = make([]float64, ret[i].n)
		var windx int
		if frstw > 0.0 {
			ret[i].weights[windx] = frstw / scale * scaleBpp
			windx++
		}
		for j := 0; j < int(count); j++ {
			ret[i].weights[windx] = 1.0 / scale * scaleBpp
			windx++
		}
		if frac > 0.0 {
			ret[i].weights[windx] = frac / scale * scaleBpp
		}
	}

	return ret
}
Example #16
0
// 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
}
Example #17
0
func ExampleTime() {
	// Example 19.a, p. 121.

	// convert degree data to radians
	r1 := 113.56833 * math.Pi / 180
	d1 := 31.89756 * math.Pi / 180
	r2 := 116.25042 * math.Pi / 180
	d2 := 28.03681 * math.Pi / 180
	r3 := make([]float64, 5)
	for i, ri := range []float64{
		118.98067, 119.59396, 120.20413, 120.81108, 121.41475} {
		r3[i] = ri * math.Pi / 180
	}
	d3 := make([]float64, 5)
	for i, di := range []float64{
		21.68417, 21.58983, 21.49394, 21.39653, 21.29761} {
		d3[i] = di * math.Pi / 180
	}
	// use JD as time to handle month boundary
	jd, err := line.Time(r1, d1, r2, d2, r3, d3,
		julian.CalendarGregorianToJD(1994, 9, 29),
		julian.CalendarGregorianToJD(1994, 10, 3))
	if err != nil {
		fmt.Println(err)
		return
	}
	y, m, d := julian.JDToCalendar(jd)
	dInt, dFrac := math.Modf(d)
	fmt.Printf("%d %s %.4f\n", y, time.Month(m), d)
	fmt.Printf("%d %s %d, at %h TD(UT)\n", y, time.Month(m), int(dInt),
		sexa.NewFmtTime(dFrac*24*3600))
	// Output:
	// 1994 October 1.2233
	// 1994 October 1, at 5ʰ TD(UT)
}
Example #18
0
func Round(v float64) float64 {
	var frac float64
	if _, frac = math.Modf(v); frac >= 0.5 {
		return math.Ceil(v)
	}
	return math.Floor(v)
}
Example #19
0
// Validate validates and normalize integer based value
func (v Integer) Validate(value interface{}) (interface{}, error) {
	if f, ok := value.(float64); ok {
		// JSON unmarshaling treat all numbers as float64, try to convert it to int if not fraction
		i, frac := math.Modf(f)
		if frac == 0.0 {
			v := int(i)
			value = &v
		}
	}
	i, ok := value.(*int)
	if !ok {
		return nil, errors.New("not an integer")
	}
	if v.Min != nil && *i < *v.Min {
		return nil, fmt.Errorf("is lower than %d", *v.Min)
	}
	if v.Max != nil && *i > *v.Max {
		return nil, fmt.Errorf("is greater than %d", *v.Max)
	}
	if len(v.Allowed) > 0 {
		found := false
		for _, allowed := range v.Allowed {
			if *i == allowed {
				found = true
				break
			}
		}
		if !found {
			// TODO: build the list of allowed values
			return nil, fmt.Errorf("not one of the allowed values")
		}
	}
	return i, nil
}
Example #20
0
// Round a float to a specific decimal place or precision
func Round(input float64, places int) (rounded float64, err error) {

	// If the float is not a number
	if math.IsNaN(input) {
		return 0.0, errors.New("Not a number")
	}

	// Find out the actual sign and correct the input for later
	sign := 1.0
	if input < 0 {
		sign = -1
		input *= -1
	}

	// Use the places arg to get the amount of precision wanted
	precision := math.Pow(10, float64(places))

	// Find the decimal place we are looking to round
	digit := input * precision

	// Get the actual decimal number as a fraction to be compared
	_, decimal := math.Modf(digit)

	// If the decimal is less than .5 we round down otherwise up
	if decimal >= 0.5 {
		rounded = math.Ceil(digit)
	} else {
		rounded = math.Floor(digit)
	}

	// Finally we do the math to actually create a rounded number
	return rounded / precision * sign, nil
}
Example #21
0
func (p Palette) Color(x float64) color.Color {
	n := x * float64(len(p))
	c1 := p[int(math.Floor(n))]
	c2 := p[int(math.Min(math.Ceil(n), float64(len(p)-1)))]
	_, t := math.Modf(n)
	return blendRGBA(c1, c2, t)
}
Example #22
0
func Round32(x float32) float32 {
	i, f := math.Modf(float64(x))
	if f >= 0.5 {
		return float32(i) + 1.0
	}
	return float32(i)
}
Example #23
0
func reqlTimeToNativeTime(timestamp float64, timezone string) (time.Time, error) {
	sec, ms := math.Modf(timestamp)

	// Convert to native time rounding to milliseconds
	t := time.Unix(int64(sec), int64(math.Floor(ms*1000+0.5))*1000*1000)

	// Caclulate the timezone
	if timezone != "" {
		hours, err := strconv.Atoi(timezone[1:3])
		if err != nil {
			return time.Time{}, err
		}
		minutes, err := strconv.Atoi(timezone[4:6])
		if err != nil {
			return time.Time{}, err
		}
		tzOffset := ((hours * 60) + minutes) * 60
		if timezone[:1] == "-" {
			tzOffset = 0 - tzOffset
		}

		t = t.In(time.FixedZone(timezone, tzOffset))
	}

	return t, nil
}
Example #24
0
func (c *FanMetrics) GetPercentile(p float64) time.Duration {
	var percentile float64

	r := (float64(len(c.Results)) + 1.0) * p
	ir, fr := math.Modf(r)

	if len(c.Results) == 0 {
		return 0
	}

	var v1 float64
	if ir >= float64(len(c.Results)) {
		v1 = float64(c.Results[len(c.Results)-1])
	} else {
		v1 = float64(c.Results[int(ir)-1])
	}

	if fr > 0.0 && ir < float64(len(c.Results)) {
		v2 := float64(c.Results[int(ir)])
		percentile = (v2-v1)*fr + v1
	} else {
		percentile = v1
	}

	return time.Duration(percentile)
}
Example #25
0
func Round64(x float64) float64 {
	i, f := math.Modf(x)
	if f >= 0.5 {
		return i + 1.0
	}
	return i
}
Example #26
0
func ExampleLen3_Extremum() {
	// Example 3.b, p. 26.
	d3, err := interp.NewLen3(12, 20, []float64{
		1.3814294,
		1.3812213,
		1.3812453,
	})
	if err != nil {
		fmt.Println(err)
		return
	}
	x, y, err := d3.Extremum()
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("distance:  %.7f AU\n", y)
	fmt.Printf("date:     %.4f\n", x)
	i, frac := math.Modf(x)
	fmt.Printf("1992 May %d, at %.64s TD",
		int(i), base.NewFmtTime(frac*24*3600))
	// Output:
	// distance:  1.3812030 AU
	// date:     17.5864
	// 1992 May 17, at 14ʰ TD
}
Example #27
0
func ExampleLen3_Zero() {
	// Example 3.c, p. 26.
	x1 := 26.
	x3 := 28.
	// the y unit doesn't matter.  working in degrees is fine
	yTable := []float64{
		base.DMSToDeg(true, 0, 28, 13.4),
		base.DMSToDeg(false, 0, 6, 46.3),
		base.DMSToDeg(false, 0, 38, 23.2),
	}
	d3, err := interp.NewLen3(x1, x3, yTable)
	if err != nil {
		fmt.Println(err)
		return
	}
	x, err := d3.Zero(false)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Printf("February %.5f\n", x)
	i, frac := math.Modf(x)
	fmt.Printf("February %d, at %.62s TD",
		int(i), base.NewFmtTime(frac*24*3600))
	// Output:
	// February 26.79873
	// February 26, at 19ʰ10ᵐ TD
}
Example #28
0
// FormatFloat converts a float64 to a formatted string. The float is rounded
// to the given precision and formatted using a comma separator for thousands.
func FormatFloat(x float64, precision int) string {

	// Round the float and get the decimal and fractional parts
	r := RoundFloat(x, precision)
	i, f := math.Modf(r)
	is := FormatThousands(int64(i))

	// If precision is less than one return the formatted integer part
	if precision <= 0 {

		return is
	}

	// Otherwise convert the fractional part to a string
	fs := strconv.FormatFloat(f, 'f', precision, 64)

	// And get the digits after the decimal point
	if x < 0 {

		fs = fs[3:]

	} else {

		fs = fs[2:]
	}

	// Concatenate the decimal and fractional parts and return
	return is + "." + fs
}
Example #29
0
/*
getBestReadSize returns the best guess as to how much data should be read to reach the target message count.

Logic used:

1 - If the target count is 1 message, recommend double the average message size of the segment, or 1k if empty.
2 - Find the largest number that will align the read to the sparse array of offsets.
*/
func (seg *Segment) getBestReadSize(msgIndex int64, msgPosition int64, targetCount int) (bestSize int) {
	if targetCount == 1 {
		if seg.msgCount == 0 {
			return 1024
		}
		return int(2 * seg.fileSize / int64(seg.msgCount))
	}

	localIndex := msgIndex - seg.firstIndex
	nearestIndexf, _ := math.Modf(float64(localIndex) / float64(default_index_offset_density))
	nearestIndex := int(nearestIndexf)

	// If nearest sparse index is already at the end of the file, just return end of file information.
	if nearestIndex == len(seg.sparseIndexOffsetList)-1 {
		return int(seg.fileSize - msgPosition)
	}

	// Is there an offset between the end and where we are that makes more sense?
	for i, offset := range seg.sparseIndexOffsetList[nearestIndex:] {
		if (i+nearestIndex)*default_index_offset_density-int(localIndex) >= targetCount {
			// Use this offset.
			return int(offset - msgPosition)
		}
	}

	// If our maximum is so big that we hit the end - just send the whole file.
	return int(seg.fileSize - msgPosition)

}
Example #30
0
// IntoWords convert numbers (float64) to words
func IntoWords(number float64) string {
	if number == 0 {
		return zero
	}

	words := []string{}
	// Minus
	if number < 0 {
		words = append(words, minus)
	}
	number = math.Abs(number)

	integer, fractional := math.Modf(number)
	if integer != 0 || fractional == 0 {
		numberIntoWords := writeOutNumbersInWords(integer)
		words = append(words, numberIntoWords...)
	}
	if fractional > 0 {
		words = append(words, point)
		fractional := round(math.Abs(fractional) * 100)
		fracIntoWords := writeOutNumbersInWords(fractional)
		words = append(words, fracIntoWords...)
	}

	return sanitize(words)
}