Example #1
0
    public static void Main(string[] args)
    {
        double average;
        Stats2 stats = new Stats2();
        average = stats.averageFloats();

        System.Console.WriteLine("The average of the values entered is " + string.Format("{0:0.00}", average));
    }
Example #2
0
        public static double NatureModifier(Stats2 s, Nature n)
        {
            int    natureIndex = (int)n;
            double retVal      = 1;

            if (natureIndex / 5 == ((int)s) - 1)
            {
                retVal += 0.1;
            }
            if (natureIndex % 5 == ((int)s) - 1)
            {
                retVal -= 0.1;
            }
            return(retVal);
        }
Example #3
0
        private void Controller_Sensor2ValueReceived(object sender, SensorValueEventArgs e)
        {
            DateTime time = DateTime.Now;

            Sensor2Data.AsyncInvoke(x =>
            {
                x.Rows.Add(new object[]
                {
                    time,
                    e.Status,
                    e.Before.Sensor1,
                    e.Before.Sensor2,
                    e.After == null ? 0f : e.After.Value.Sensor1,
                    e.After == null ? 0f : e.After.Value.Sensor2,
                    e.Delta == null ? 0f : e.Delta.Value.Sensor1,
                    e.Delta == null ? 0f : e.Delta.Value.Sensor2
                });
            });
            SensorChart.AsyncInvoke(x =>
            {
                if (!x.IsDisposed)
                {
                    x.Series["Sensor1Before"].Points.AddXY(time, e.Before.Sensor1);
                    x.Series["Sensor1After"].Points.AddXY(time, e.After == null ? 0f : e.After.Value.Sensor1);
                    x.Series["Sensor1MaxPlus"].Points.AddXY(time, 3.5f);
                    x.Series["Sensor1MaxMinus"].Points.AddXY(time, -3.5f);
                    x.Series["Sensor1MinPlus"].Points.AddXY(time, 0.75f);
                    x.Series["Sensor1MinMinus"].Points.AddXY(time, -0.75f);

                    x.Series["Sensor2Before"].Points.AddXY(time, e.Before.Sensor2);
                    x.Series["Sensor2After"].Points.AddXY(time, e.After == null ? 0f : e.After.Value.Sensor2);
                    x.Series["Sensor2MaxPlus"].Points.AddXY(time, 3.5f);
                    x.Series["Sensor2MaxMinus"].Points.AddXY(time, -3.5f);
                    x.Series["Sensor2MinPlus"].Points.AddXY(time, 0.75f);
                    x.Series["Sensor2MinMinus"].Points.AddXY(time, -0.75f);

                    x.Series["Sensor1Delta"].Points.AddXY(time, e.Delta == null ? 0f : e.Delta.Value.Sensor1);
                    x.Series["Sensor2Delta"].Points.AddXY(time, e.Delta == null ? 0f : e.Delta.Value.Sensor2);
                }
            });
            switch (e.Status)
            {
            case StatusCode.PASS:
            {
                Stats1.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["Passed"].Points.Count > 0)
                            {
                                x.Series["Passed"].Points[0].SetValueXY("Passed", x.Series["Passed"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["Passed"].Points.AddXY("Passed", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.FAILED:
            {
                Stats1.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["Failed"].Points.Count > 0)
                            {
                                x.Series["Failed"].Points[0].SetValueXY("Failed", x.Series["Failed"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["Failed"].Points.AddXY("Failed", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.FIRST_BENDED:
            {
                Stats2.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["FirstBended"].Points.Count > 0)
                            {
                                x.Series["FirstBended"].Points[0].SetValueXY("FirstBended", x.Series["FirstBended"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["FirstBended"].Points.AddXY("FirstBended", 1);
                            }
                        }
                    });
                break;
            }

            case StatusCode.SECOND_BENDED:
            {
                Stats2.AsyncInvoke(x =>
                    {
                        if (!x.IsDisposed)
                        {
                            if (x.Series["SecondBended"].Points.Count > 0)
                            {
                                x.Series["SecondBended"].Points[0].SetValueXY("SecondBended", x.Series["SecondBended"].Points[0].GetValueByName("Y") + 1);
                                x.ResetAutoValues();
                            }
                            else
                            {
                                x.Series["SecondBended"].Points.AddXY("SecondBended", 1);
                            }
                        }
                    });
                break;
            }
            }
        }