Exemplo n.º 1
0
 public void setValue(FloatData value)
 {
     Value.Value = MaxValue.Value;
 }
Exemplo n.º 2
0
 public void SubtractValuetoObj(FloatData data)
 {
     ValueObj.Value -= data.Value;
 }
 public void UpdateTextWithFloatData(FloatData data)
 {
     textToReplace.text = data.value.ToString();
 }
Exemplo n.º 4
0
 public void UpdateValue(FloatData data)
 {
     var newData = data as FloatData;
     if (newData != null) value += newData.value;
 }
Exemplo n.º 5
0
 public void UpdateImage(FloatData data)
 {
     img.fillAmount = data.value;
 }
Exemplo n.º 6
0
 public void UpdateImageComponent(FloatData dataObj)
 {
     imageComponent.fillAmount = dataObj.value;
 }
Exemplo n.º 7
0
 public void AddDeltaTime(FloatData modifier)
 {
     AddDeltaTime(modifier.value);
 }
Exemplo n.º 8
0
 public void AddValueToObj(FloatData data)
 {
     ValueObj.Value += data.Value;
 }
Exemplo n.º 9
0
 public void SubtractValue(FloatData data)
 {
     data.Value -= Data.Value;
 }
Exemplo n.º 10
0
        private List <PValue> GetFloatArchivedValues(int tagid, DateTime begin, DateTime end)
        {
            List <PValue> pvalues = new List <PValue>();

            //判断tagid范围是否正常
            if (tagid <= 0)
            {
                return(pvalues);                   //tagid必须大于0,否则返回空pvalues
            }
            //获取历史数据原始值
            //golden数据库获取浮点型历史原始数据的接口是GetFloatArchivedValues(id, count, begin, end)。(读插值是GetFloatInterpoValues())
            //count是一个输入/输出参数。该接口根据输入的count申请相应大小的内存,输出的count为实际查询到的历史数据数量。
            //count大小没有限制,但是单个程序可以寻址的内存大小有限制.
            //——如果1秒一个实时数据,一天实时数据为86400条,读出的List<PValue>占用内存15M左右。
            //一般设置count大小为1000000,即一百万条记录,如果按照1秒一个实时数据,大概存放10天左右的数据,占用内存为150M数量级
            //在概化计算中,如果直接取用原始实时数据,计算周期不应超过1天。
            const int maxCount = 1000000;
            int       count    = this._iHistorian.GetNumberArchivedValuesCount(tagid, begin, end); //实际情况,应该根据返回的数量做出不同的处理
            //
            Entity <FloatData> list = new Entity <FloatData>();

            if (count == 0)
            {
                return(pvalues);                   //如果count为0,直接返回空pvalues。外部程序可以根据pvalues.count是否为0来处理
            }
            if (count <= maxCount && count > 0)    //如果记录数量小于100000,且不为0,则直接读取
            {
                try
                {
                    list = this._iHistorian.GetFloatArchivedValues(tagid, count, begin, end); //读取历史数据
                }
                catch (RTDBException ex)
                {
                    //将golden的异常PgimDataException记录在_exception中,并以PgimDataException的名称继续抛出异常
                    this._exception = ex.ToString();
                    throw new Exception(ex.ToString());     //将pgim的异常继续向外传递。
                }
                //golden数据库读取历史数据,返回数据集的是从起始时间后最近一个数据开始
                //实际需要的是从起始时间前最近一个数据开始,只要返回的第一个数据时间戳不等于begin,就应该向前补充一个数据
                //获取历史数据的起始时间begin为8:00:00,会自动找到该时间前的最近一个数据,比如7:59:50,将该数据做为返回数据集的第一个数据,并将时间修正为8:00:00
                if (list.Data[0].Time > begin)
                {
                    FloatData firstdata = new FloatData();
                    try
                    {
                        firstdata = this._iHistorian.GetFloatSingleValue(tagid, begin, HistorianMode.PREVIOUS);//获取起始时刻前最近的一个数据
                    }
                    catch (RTDBException ex)
                    {
                        //将golden的异常PgimDataException记录在_exception中,并以PgimDataException的名称继续抛出异常
                        this._exception = ex.ToString();
                        throw new Exception(ex.ToString());     //将pgim的异常继续向外传递。
                    }
                    //这里也存在两种可能,一种是begin时间点之前确实再没有其他数据,该时间点后的数据已经是数据库存储的第一个数据;另一种是可以找到begin时间点前的数据
                    if (firstdata != null)
                    {   //一般情况下,都能在begin时间点前,找到一个数据点,用该数据点的值替代begin时刻的值
                        firstdata.Time = begin;
                        list.Data.Insert(0, firstdata);
                        list.Count += 1;
                    }
                    else
                    {   //特殊情况下,仅当当前时刻已经位于数据库存储数据的最前端,begin时刻点前再无其他时刻的值。
                        //该情况下,用已经取得的第一个点的值,作为begin时刻的值
                        firstdata          = new FloatData();
                        firstdata.Id       = tagid;
                        firstdata.Value    = list.Data[0].Value;
                        firstdata.Time     = begin;
                        firstdata.Error    = 0;
                        firstdata.Qualitie = Quality.GOOD;
                        firstdata.Ms       = 0;

                        list.Data.Insert(0, firstdata);
                        list.Count += 1;
                    }
                }
                //golden数据库读取历史数据,返回数据集的是到截止时间前最后一个数据为止。
                //根据需要,在后面补充一个空数据,仅记录截止时间end,用于计算截止时间前最后一个数据的timespan
                if (list.Data[list.Count - 1].Time < end)
                {
                    FloatData lastdata = new FloatData();
                    lastdata.Time = end;
                    list.Data.Add(lastdata);
                    list.Count += 1;
                }
                //list是一个起始时间从begin开始,截止时间为end的点集合.
                //其头部begin时间点,有可能恰好对应一个原始值,有可能用前一时刻的值补足的值。
                //其尾部end时间点,有可能恰好对应一个原始值,有可能是用end时刻补足的一个值。
                //GetFloatSingleValue如过返回0个值,则直接退出
                //GetFloatSingleValue如果仅返回一个值,则要么会在begin补值,要么会在end补值。要么会在两边都补。
                //GetFloatSingleValue如果仅返回两个值,有可能恰好在两边。这样两边都不需要补值
                //因此list一定是一个至少包含两个元素的列表集合。(GetFloatSingleValue返回0个值的情况,已经直接处理了)
                //将结果转换为pvalue
                pvalues = FloatDatatoPValueHist(list);
            }
            else if (count > maxCount)
            //如果记录数量大于100000,怎么处理
            {
                //按晋晖说的应该分批读取,但实际上,对于概化计算,还要送到计算引擎,没有办法分批,因此必须记录log,并略过
                //另外的处理方法就是做好规划控制每次读取的时间间隔
                //在概化计算引擎中,采用第二种方式来控制最大数量
            }
            return(pvalues);
        }
Exemplo n.º 11
0
        public void collect(SpeechResult result)
        {
            Token token = result.getResult().getBestToken();

            float[] componentScore, featureVector, posteriors, tmean;
            int[]   len;
            float   dnom, wtMeanVar, wtDcountVar, wtDcountVarMean, mean;
            int     mId, cluster;
            int     numStreams, gauPerState;

            if (token == null)
            {
                throw new Exception("Best token not found!");
            }

            do
            {
                FloatData    feature = (FloatData)token.getData();
                ISearchState ss      = token.getSearchState();

                if (!(ss is IHMMSearchState && ss.isEmitting()))
                {
                    token = token.getPredecessor();
                    continue;
                }

                componentScore = token.calculateComponentScore(feature);
                featureVector  = FloatData.toFloatData(feature).getValues();
                mId            = (int)((IHMMSearchState)token.getSearchState()).getHMMState()
                                 .getMixtureId();
                if (loader is Sphinx3Loader && ((Sphinx3Loader)loader).hasTiedMixtures())
                {
                    // use CI phone ID for tied mixture model
                    mId = ((Sphinx3Loader)loader).getSenone2Ci()[mId];
                }
                len         = loader.getVectorLength();
                numStreams  = loader.getNumStreams();
                gauPerState = loader.getNumGaussiansPerState();
                posteriors  = this.computePosterios(componentScore, numStreams);
                int featVectorStartIdx = 0;

                for (int i = 0; i < numStreams; i++)
                {
                    for (int j = 0; j < gauPerState; j++)
                    {
                        cluster = means.getClassIndex(mId * numStreams
                                                      * gauPerState + i * gauPerState + j);
                        dnom = posteriors[i * gauPerState + j];
                        if (dnom > 0f)
                        {
                            tmean = loader.getMeansPool().get(
                                mId * numStreams * gauPerState + i
                                * gauPerState + j);

                            for (int k = 0; k < len[i]; k++)
                            {
                                mean = posteriors[i * gauPerState + j]
                                       * featureVector[k + featVectorStartIdx];
                                wtMeanVar = mean
                                            * loader.getVariancePool().get(
                                    mId * numStreams * gauPerState + i
                                    * gauPerState + j)[k];
                                wtDcountVar = dnom
                                              * loader.getVariancePool().get(
                                    mId * numStreams * gauPerState + i
                                    * gauPerState + j)[k];

                                for (int p = 0; p < len[i]; p++)
                                {
                                    wtDcountVarMean = wtDcountVar * tmean[p];

                                    for (int q = p; q < len[i]; q++)
                                    {
                                        regLs[cluster][i][k][p][q] += wtDcountVarMean
                                                                      * tmean[q];
                                    }
                                    regLs[cluster][i][k][p][len[i]] += wtDcountVarMean;
                                    regRs[cluster][i][k][p]         += wtMeanVar * tmean[p];
                                }
                                regLs[cluster][i][k][len[i]][len[i]] += wtDcountVar;
                                regRs[cluster][i][k][len[i]]         += wtMeanVar;
                            }
                        }
                    }
                    featVectorStartIdx += len[i];
                }
                token = token.getPredecessor();
            } while (token != null);
        }
Exemplo n.º 12
0
 public override void Work()
 {
     fromNameId = NameIdObj as FloatData;
     workEvent.Invoke();
 }
Exemplo n.º 13
0
    public void UnApply(FloatData data)
    {
        int value = Convert.ToInt32(Mathf.Floor(data.val));

        this.val -= value;
    }
Exemplo n.º 14
0
 public void ChangeTargetValue(FloatData targetData)
 {
     targetData.value += DeltaValue.value;
 }
Exemplo n.º 15
0
 public void UpdateImage(FloatData data)     //not naming it health because you can use this for any type of bar to update data
 {
     img.fillAmount = data.value;
 }
Exemplo n.º 16
0
 public void AddValue(FloatData data)
 {
     data.Value += Data.Value;
 }
Exemplo n.º 17
0
 private void dumpData(Data data)
 {
     if (data == null)
     {
         [email protected]("Data: null");
     }
     else if (data is Signal)
     {
         if (this.outputSignals)
         {
             [email protected](new StringBuilder().append("Signal: ").append(data).toString());
         }
     }
     else if (data is DoubleData)
     {
         DoubleData doubleData = (DoubleData)data;
         double[]   values     = doubleData.getValues();
         [email protected](new StringBuilder().append("Frame ").append(values.Length).toString());
         double[] array = values;
         int      num   = array.Length;
         for (int i = 0; i < num; i++)
         {
             double num2 = array[i];
             [email protected](new StringBuilder().append(' ').append(this.formatter.format(num2)).toString());
         }
         [email protected]();
     }
     else if (data is SpeechClassifiedData)
     {
         SpeechClassifiedData speechClassifiedData = (SpeechClassifiedData)data;
         double[]             values = speechClassifiedData.getValues();
         [email protected]("Frame ");
         if (speechClassifiedData.isSpeech())
         {
             [email protected]('*');
         }
         else
         {
             [email protected](' ');
         }
         [email protected](new StringBuilder().append(" ").append(values.Length).toString());
         double[] array = values;
         int      num   = array.Length;
         for (int i = 0; i < num; i++)
         {
             double num2 = array[i];
             [email protected](new StringBuilder().append(' ').append(this.formatter.format(num2)).toString());
         }
         [email protected]();
     }
     else if (data is FloatData)
     {
         FloatData floatData = (FloatData)data;
         float[]   values2   = floatData.getValues();
         [email protected](new StringBuilder().append("Frame ").append(values2.Length).toString());
         float[] array2 = values2;
         int     num    = array2.Length;
         for (int i = 0; i < num; i++)
         {
             float num3 = array2[i];
             [email protected](new StringBuilder().append(' ').append(this.formatter.format((double)num3)).toString());
         }
         [email protected]();
     }
 }
Exemplo n.º 18
0
 public void SubtractValue(FloatData obj)
 {
     Data.Value -= obj.Value;
 }
Exemplo n.º 19
0
 public void AddToValue(FloatData data)
 {
     AddToValue(data.value);
 }
Exemplo n.º 20
0
 public void AddValue(FloatData obj)
 {
     Data.Value += obj.Value;
 }
Exemplo n.º 21
0
 public void PartValue(FloatData data)
 {
     data.Value /= Data.Value;
 }
Exemplo n.º 22
0
 public void DisplayValue(FloatData data)
 {
     img.fillAmount = data.value;
 }
Exemplo n.º 23
0
 public void SetValue(FloatData data)
 {
     var newData = data as FloatData;
     if (newData != null) value = newData.value;
 }
Exemplo n.º 24
0
 public void OnDivideValue(FloatData outsideData)
 {
     outsideData.Value /= Data.Value;
 }
Exemplo n.º 25
0
 // -------------------------------------------------------------------------
 public void ActionCompareToTarget(FloatData value)
 {
     ActionCompareToTarget(value.GetCurrentValue());
 }
Exemplo n.º 26
0
 public void Apply(FloatData data)
 {
     this.val += data.val;
 }
Exemplo n.º 27
0
 public void OnPowerUp(FloatData outsideData)
 {
     outsideData.Value += Data.Value;
 }
Exemplo n.º 28
0
 public void UnApply(FloatData data)
 {
     this.val -= data.val;
 }
Exemplo n.º 29
0
 private void OnTriggerEnter(Collider other)
 {
     ProjectileSpeed = ProjectileUpgrade;
     projectile.AddForce(0, 0, ProjectileSpeed.Value);
 }
Exemplo n.º 30
0
 private void OnEnable()
 {
     moveSpeed  = normalSpeed;
     controller = GetComponent <CharacterController>();
     StartCoroutine(Move());
 }