示例#1
0
        private List <TokenInfo> ExtSinus(List <TokenInfo> Arguments)
        {
            var result = new List <TokenInfo>();

            if (Arguments.Count != 1)
            {
                SetError("Invalid argument count");
                return(result);
            }
            double functionResult = 0;

            if (!m_Parser.EvaluateTokensNumeric(0, Arguments, out functionResult))
            {
                SetError("Invalid argument");
                return(result);
            }
            var resultValue = new TokenInfo()
            {
                Type    = TokenInfo.TokenType.LITERAL_NUMBER,
                Content = Math.Sin(functionResult * Math.PI / 180.0f).ToString("0.00000000000000000000", System.Globalization.CultureInfo.InvariantCulture)
            };

            result.Add(resultValue);
            return(result);
        }
示例#2
0
        private void GenerateValues()
        {
            m_Parser = new Parser.ASMFileParser();

            m_Parser.AddExtFunction("sin", 1, 1, ExtSinus);
            m_Parser.AddExtFunction("cos", 1, 1, ExtCosinus);
            m_Parser.AddExtFunction("tan", 1, 1, ExtTan);

            double startValue = Util.StringToDouble(m_Project.ValueTable.StartValue);
            double endValue   = Util.StringToDouble(m_Project.ValueTable.EndValue);
            double stepValue  = Util.StringToDouble(m_Project.ValueTable.StepValue);

            if ((startValue != endValue) &&
                (stepValue == 0))
            {
                SetError("Step value must not be equal zero");
                return;
            }
            if ((startValue <= endValue) &&
                (stepValue < 0))
            {
                SetError("Step value must be positive");
                return;
            }
            if ((startValue >= endValue) &&
                (stepValue > 0))
            {
                SetError("Step value must be negative");
                return;
            }

            if (checkClearPreviousValues.Checked)
            {
                m_Project.ValueTable.Values.Clear();
                listValues.Items.Clear();
            }

            double curValue   = startValue;
            bool   completed  = false;
            bool   firstValue = true;
            double lastValue  = curValue;

            do
            {
                m_Parser.AddConstantF("x", curValue, 0, "", 0, 1);
                var tokens = m_Parser.ParseTokenInfo(m_Project.ValueTable.Formula, 0, m_Project.ValueTable.Formula.Length);
                if (tokens == null)
                {
                    SetError(m_Parser.GetError().Code.ToString());
                    return;
                }
                double result = 0.0;
                if (!m_Parser.EvaluateTokensNumeric(0, tokens, out result))
                {
                    SetError(m_Parser.GetError().Code.ToString());
                    return;
                }

                if (m_Project.ValueTable.GenerateDeltas)
                {
                    if (!firstValue)
                    {
                        m_Project.ValueTable.Values.Add((result - lastValue).ToString());
                        listValues.Items.Add((result - lastValue).ToString());
                    }
                    firstValue = false;
                }
                else
                {
                    m_Project.ValueTable.Values.Add(result.ToString());
                    listValues.Items.Add(result.ToString());
                }

                lastValue = result;
                curValue += stepValue;

                if (startValue == endValue)
                {
                    completed = true;
                }
                if ((stepValue > 0) &&
                    (curValue > endValue))
                {
                    completed = true;
                }
                if ((stepValue < 0) &&
                    (curValue < endValue))
                {
                    completed = true;
                }
            }while (!completed);

            SetError("OK");

            m_Project.ValueTable.Data = new ByteBuffer((uint)m_Project.ValueTable.Values.Count);
            int index = 0;

            foreach (var entry in m_Project.ValueTable.Values)
            {
                m_Project.ValueTable.Data.SetU8At(index, GR.Convert.ToU8(entry));

                ++index;
            }
        }
示例#3
0
        private void GenerateValues()
        {
            m_Parser = new Parser.ASMFileParser();

            m_Parser.AddExtFunction("sin", 1, 1, ExtSinus);

            double startValue = Util.StringToDouble(m_Project.ValueTable.StartValue);
            double endValue   = Util.StringToDouble(m_Project.ValueTable.EndValue);
            double stepValue  = Util.StringToDouble(m_Project.ValueTable.StepValue);

            if ((startValue != endValue) &&
                (stepValue == 0))
            {
                SetError("Step value must not be equal zero");
                return;
            }
            if ((startValue <= endValue) &&
                (stepValue < 0))
            {
                SetError("Step value must be positive");
                return;
            }
            if ((startValue >= endValue) &&
                (stepValue > 0))
            {
                SetError("Step value must be negative");
                return;
            }

            if (checkClearPreviousValues.Checked)
            {
                m_Project.ValueTable.Values.Clear();
                listValues.Items.Clear();
            }

            double curValue  = startValue;
            bool   completed = false;

            do
            {
                m_Parser.AddConstantF("x", curValue, 0, "", 0, 1);
                var tokens = m_Parser.ParseTokenInfo(m_Project.ValueTable.Formula, 0, m_Project.ValueTable.Formula.Length);
                if (tokens == null)
                {
                    SetError(m_Parser.GetError().Code.ToString());
                    return;
                }
                double result = 0.0;
                if (!m_Parser.EvaluateTokensNumeric(0, tokens, out result))
                {
                    SetError(m_Parser.GetError().Code.ToString());
                    return;
                }

                m_Project.ValueTable.Values.Add(result.ToString());
                listValues.Items.Add(result.ToString());

                curValue += stepValue;

                if (startValue == endValue)
                {
                    completed = true;
                }
                if ((stepValue > 0) &&
                    (curValue > endValue))
                {
                    completed = true;
                }
                if ((stepValue < 0) &&
                    (curValue < endValue))
                {
                    completed = true;
                }
            }while (!completed);

            SetError("OK");
        }