Golang util.ParseFloat函數代碼示例

func (b *Poisson) Run() {
	var err error
	λ := 1.0
	sampler := NewPoissonSampler(λ)
	for {
		select {
		case ruleI := <-b.inrule:
			// set a parameter of the block
			rule, ok := ruleI.(map[string]interface{})
			if !ok {
				b.Error(errors.New("couldn't assert rule to map"))
			}
			λ, err = util.ParseFloat(rule, "Rate")
			if err != nil {
				b.Error(err)
			}
			sampler = NewPoissonSampler(λ)
		case <-b.quit:
			// quit the block
			return
		case <-b.inpoll:
			// deal with a poll request
			b.out <- map[string]interface{}{
				"sample": float64(sampler()),
			}
		case c := <-b.queryrule:
			// deal with a query request
			c <- map[string]interface{}{
				"Rate": λ,
			}
		}
	}
}

func (b *Exponential) Run() {
	var err error
	λ := 1.0
	for {
		select {
		case ruleI := <-b.inrule:
			// set a parameter of the block
			rule, ok := ruleI.(map[string]interface{})
			if !ok {
				b.Error(errors.New("couldn't assert rule to map"))
			}
			λ, err = util.ParseFloat(rule, "rate")
			if err != nil {
				b.Error(err)
			}
		case <-b.quit:
			// quit the block
			return
		case <-b.inpoll:
			// deal with a poll request
			b.out <- map[string]interface{}{
				"sample": rand.ExpFloat64(),
			}
		case c := <-b.queryrule:
			// deal with a query request
			c <- map[string]interface{}{
				"rate": λ,
			}
		}
	}
}

// Run is the block's main loop. Here we listen on the different channels we set up.
// this is actually the Zipf-Manadlebrot "law".
// http://en.wikipedia.org/wiki/Zipf%E2%80%93Mandelbrot_law
// the parameter `v` is denoted `q` on wikipedia.
func (b *Zipf) Run() {
	var err error
	var s, v, imax float64
	s = 2.0
	v = 5.0
	imax = 99.0
	r := rand.New(rand.NewSource(12345))
	sampler := rand.NewZipf(r, s, v, uint64(imax))
	for {
		select {
		case ruleI := <-b.inrule:
			// set a parameter of the block
			rule, ok := ruleI.(map[string]interface{})
			if !ok {
				b.Error(errors.New("couldn't assert rule to map"))
			}
			s, err = util.ParseFloat(rule, "s")
			if err != nil {
				b.Error(err)
			}
			v, err = util.ParseFloat(rule, "v")
			if err != nil {
				b.Error(err)
			}
			imax, err = util.ParseFloat(rule, "N")
			if err != nil {
				b.Error(err)
			}
			sampler = rand.NewZipf(r, s, v, uint64(imax))
		case <-b.quit:
			// quit the block
			return
		case <-b.inpoll:
			// deal with a poll request
			b.out <- map[string]interface{}{
				"sample": float64(sampler.Uint64()),
			}
		case c := <-b.queryrule:
			// deal with a query request
			c <- map[string]interface{}{
				"s": s,
				"v": v,
				"N": imax,
			}
		}
	}
}

// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *Gaussian) Run() {
	var err error
	mean := 0.0
	stddev := 1.0

	for {
		select {
		case ruleI := <-b.inrule:
			// set a parameter of the block
			rule, ok := ruleI.(map[string]interface{})
			if !ok {
				b.Error(errors.New("couldn't assert rule to map"))
			}
			mean, err = util.ParseFloat(rule, "Mean")
			if err != nil {
				b.Error(err)
			}
			stddev, err = util.ParseFloat(rule, "StdDev")
			if err != nil {
				b.Error(err)
			}
		case <-b.quit:
			// quit the block
			return
		case <-b.inpoll:
			// deal with a poll request
			b.out <- map[string]interface{}{
				"sample": rand.NormFloat64()*stddev + mean,
			}
		case MsgChan := <-b.queryrule:
			// deal with a query request
			out := map[string]interface{}{
				"Mean":   mean,
				"StdDev": stddev,
			}
			MsgChan <- out
		}
	}
}

// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *PackByCount) Run() {
	var batch []interface{}
	var packSize int

	for {
		select {
		case ruleI := <-b.inrule:
			packSizeTmp, err := util.ParseFloat(ruleI, "MaxCount")
			if err != nil {
				b.Error("error parsing batch size")
				break
			}

			packSize = int(packSizeTmp)
			batch = nil

		case <-b.quit:
			// quit the block
			return
		case m := <-b.in:
			if packSize == 0 {
				break
			}

			if len(batch) == packSize {
				b.out <- map[string]interface{}{
					"Pack": batch,
				}
				batch = nil
			}

			batch = append(batch, m)

		case <-b.clear:
			batch = nil
		case <-b.flush:
			b.out <- map[string]interface{}{
				"Pack": batch,
			}
			batch = nil
		case r := <-b.queryrule:
			r <- map[string]interface{}{
				"MaxCount": packSize,
			}
		}
	}
}

// connects to an NSQ topic and emits each message into streamtools.
func (b *ToNSQMulti) Run() {
	var err error
	var nsqdTCPAddrs string
	var topic string
	var writer *nsq.Producer
	var batch [][]byte
	interval := time.Duration(1 * time.Second)
	maxBatch := 100

	conf := nsq.NewConfig()

	dump := time.NewTicker(interval)
	for {
		select {
		case <-dump.C:
			if writer == nil || len(batch) == 0 {
				break
			}
			err = writer.MultiPublish(topic, batch)
			if err != nil {
				b.Error(err.Error())
			}

			batch = nil
		case ruleI := <-b.inrule:
			//rule := ruleI.(map[string]interface{})

			topic, err = util.ParseString(ruleI, "Topic")
			if err != nil {
				b.Error(err)
				break
			}

			nsqdTCPAddrs, err = util.ParseString(ruleI, "NsqdTCPAddrs")
			if err != nil {
				b.Error(err)
				break
			}

			intervalS, err := util.ParseString(ruleI, "Interval")
			if err != nil {
				b.Error("bad input")
				break
			}

			dur, err := time.ParseDuration(intervalS)
			if err != nil {
				b.Error(err)
				break
			}

			if dur <= 0 {
				b.Error("interval must be positive")
				break
			}

			batchSize, err := util.ParseFloat(ruleI, "MaxBatch")
			if err != nil {
				b.Error("error parsing batch size")
				break
			}

			if writer != nil {
				writer.Stop()
			}

			maxBatch = int(batchSize)
			interval = dur

			dump.Stop()
			dump = time.NewTicker(interval)
			writer, err = nsq.NewProducer(nsqdTCPAddrs, conf)
			if err != nil {
				b.Error(err)
				break
			}
			topic = topic
			nsqdTCPAddrs = nsqdTCPAddrs
		case msg := <-b.in:
			if writer == nil {
				break
			}

			msgByte, err := json.Marshal(msg)
			if err != nil {
				b.Error(err)
			}
			batch = append(batch, msgByte)

			if len(batch) > maxBatch {
				err := writer.MultiPublish(topic, batch)
				if err != nil {
					b.Error(err)
					break
				}
				batch = nil
			}
		case <-b.quit:
			if writer != nil {
//.........這裏部分代碼省略.........

// Run is the block's main loop. Here we listen on the different channels we set up.
func (b *Timeseries) Run() {

	var err error
	//var path, lagStr string
	var path string
	var tree *jee.TokenTree
	//var lag time.Duration
	var data tsData
	var numSamples float64

	// defaults
	numSamples = 1

	for {
		select {
		case ruleI := <-b.inrule:
			// set a parameter of the block
			rule, ok := ruleI.(map[string]interface{})
			if !ok {
				b.Error(errors.New("could not assert rule to map"))
			}
			path, err = util.ParseString(rule, "Path")
			if err != nil {
				b.Error(err)
				continue
			}
			tree, err = util.BuildTokenTree(path)
			if err != nil {
				b.Error(err)
				continue
			}
			/*
				lagStr, err = util.ParseString(rule, "Lag")
				if err != nil {
					b.Error(err)
					continue
				}
				lag, err = time.ParseDuration(lagStr)
				if err != nil {
					b.Error(err)
					continue
				}
			*/
			numSamples, err = util.ParseFloat(rule, "NumSamples")
			if err != nil {
				b.Error(err)
				continue
			}
			data = tsData{
				Values: make([]tsDataPoint, int(numSamples)),
			}

		case <-b.quit:
			// quit * time.Second the block
			return
		case msg := <-b.in:
			if tree == nil {
				continue
			}
			if data.Values == nil {
				continue
			}
			// deal with inbound data
			v, err := jee.Eval(tree, msg)
			if err != nil {
				b.Error(err)
				continue
			}
			var val float64
			switch v := v.(type) {
			case float32:
				val = float64(v)
			case int:
				val = float64(v)
			case float64:
				val = v
			}

			//t := float64(time.Now().Add(-lag).Unix())
			t := float64(time.Now().Unix())

			d := tsDataPoint{
				Timestamp: t,
				Value:     val,
			}
			data.Values = append(data.Values[1:], d)
		case MsgChan := <-b.queryrule:
			// deal with a query request
			MsgChan <- map[string]interface{}{
				//"Window":     lagStr,
				"Path":       path,
				"NumSamples": numSamples,
			}
		case MsgChan := <-b.querystate:
			out := map[string]interface{}{
				"timeseries": data,
			}
			MsgChan <- out
		case <-b.inpoll:
//.........這裏部分代碼省略.........

// connects to an NSQ topic and emits each message into streamtools.
func (b *FromNSQ) Run() {
	var reader *nsq.Reader
	var topic, channel, lookupdAddr string
	var maxInFlight float64
	var err error
	toOut := make(chan interface{})
	toError := make(chan error)

	for {
		select {
		case msg := <-toOut:
			b.out <- msg
		case err := <-toError:
			b.Error(err)
		case ruleI := <-b.inrule:
			// convert message to a map of string interfaces
			// aka keys are strings, values are empty interfaces
			rule := ruleI.(map[string]interface{})

			topic, err = util.ParseString(rule, "ReadTopic")
			if err != nil {
				b.Error(err)
				continue
			}

			lookupdAddr, err = util.ParseString(rule, "LookupdAddr")
			if err != nil {
				b.Error(err)
				continue
			}
			maxInFlight, err = util.ParseFloat(rule, "MaxInFlight")
			if err != nil {
				b.Error(err)
				continue
			}
			channel, err = util.ParseString(rule, "ReadChannel")
			if err != nil {
				b.Error(err)
				continue
			}

			if reader != nil {
				reader.Stop()
			}

			reader, err = nsq.NewReader(topic, channel)
			if err != nil {
				b.Error(err)
				continue
			}
			reader.SetMaxInFlight(int(maxInFlight))

			h := readWriteHandler{toOut, toError}
			reader.AddHandler(h)

			err = reader.ConnectToLookupd(lookupdAddr)
			if err != nil {
				b.Error(err)
				continue
			}

		case <-b.quit:
			if reader != nil {
				reader.Stop()
			}
			return
		case c := <-b.queryrule:
			c <- map[string]interface{}{
				"ReadTopic":   topic,
				"ReadChannel": channel,
				"LookupdAddr": lookupdAddr,
				"MaxInFlight": maxInFlight,
			}
		}
	}
}