Beispiel #1
0
        public void HandleException(Exception ex, IErrorHandler _errorHandler)
        {
            HandleCustomFunctionsErrors(ex as CompilationException);

            var message = ex.Message + Environment.NewLine + (ex.InnerException?.Message ?? "");

            _errorHandler.DispalyError(message, Strings.Error);

            if (!ex.IsInternal())
            {
                _errorHandler.LogError(message, ErrorType.General, ex);
            }
        }
 private void ChartAreaValuesView1_AddClicked(object sender, EventArgs e)
 {
     if (SharedViewState.Instance.ExpressionText != "")
     {
         try
         {
             SharedViewState.Instance.CustomFunctionsEditor.ClearHighlightedErrors();
             CurrentChart.AddFunction(_expressionsEvaluator.Evaluate(SharedViewState.Instance.ExpressionText,
                                                                     SharedViewState.Instance.CustomFunctionsText,
                                                                     _calculationsMode));
         }
         catch (Exception ex)
         {
             ExceptionsHandler.Instance.HandleException(ex, _errorHandler);
         }
     }
     else
     {
         _errorHandler.DispalyError(Strings.GUI_addToChartButton_Click_Expression_should_not_be_empty_,
                                    Strings.GUI_numericalOperationButton_Click_Warning_);
     }
 }
        private void _view_CalculateClicked(object sender, EventArgs e)
        {
            if (_expressionTextProvider.Text != "")
            {
                try
                {
                    _customFunctionsEditor.ClearHighlightedErrors();
                    var function = _expressionsEvaluator.Evaluate(_expressionTextProvider.Text,
                                                                  _customFunctionsEditor.Text, _calculationsMode);

                    var x = _view.X;
                    var y = _view.Y;
                    var z = new Complex(x, y);

                    dynamic result = function.EvaluateDynamic(x, y);

                    var resultStr = ScriptingExtensions.ToMathString(result);

                    _view.AddResult(_expressionTextProvider.Text,
                                    _calculationsMode == CalculationsMode.Complex
                            ? z.ToMathString()
                            : (_calculationsMode == CalculationsMode.Fxy
                                ? $"{x.ToMathString()}, {y.ToMathString()}"
                                : x.ToMathString()), resultStr);
                }
                catch (Exception ex)
                {
                    _exceptionsHandler.HandleException(ex);
                }
            }
            else
            {
                _errorHandler.DispalyError(Strings.GUI_addToChartButton_Click_Expression_should_not_be_empty_,
                                           Strings.GUI_numericalOperationButton_Click_Warning_);
            }
        }
Beispiel #4
0
        private void _view_ComputeClicked(object sender, EventArgs e)
        {
            if (_calculationsMode == CalculationsMode.Real)
            {
                try
                {
                    customFunctionsEditor.ClearHighlightedErrors();
                    var function = expressionsEvaluator.Evaluate(_expressionTextProvider.Text,
                                                                 customFunctionsEditor.Text, _calculationsMode);

                    Func <double, double> fx = x => function.Evaluate(x);

                    var result = double.NaN;
                    var eps    = _view.Epsilon;

                    if (_view.SelectedOperation == Strings.Derivative ||
                        _view.SelectedOperation == Strings.Function_root)
                    {
                        if (double.IsNaN(eps))
                        {
                            _errorHandler.DispalyError(Strings.GivenΕIsNotValid, Strings.Error);
                            return;
                        }
                        if (!(eps > 0.0) || !(eps < 1))
                        {
                            _errorHandler.DispalyError(
                                Strings.GivenΕIsNotValidΕShouldBeSmallPositiveNumber, Strings.Error);
                            return;
                        }
                    }

                    var parametersStr = "";


                    if (_view.SelectedOperation == Strings.Integral)
                    {
                        result =
                            ((dynamic)
                             Convert.ChangeType(
                                 NumericalMethodsInfo.Instance._methods[_view.SelectedOperation][_view.SelectedMethod
                                 ],
                                 _integrationType))
                                (fx, _view.A, _view.B, _view.N);
                        parametersStr = $"a={_view.A.ToMathString()}; b={_view.B.ToMathString()}; N={_view.N}";
                    }
                    else if (_view.SelectedOperation == Strings.Derivative)
                    {
                        result =
                            ((dynamic)
                             Convert.ChangeType(
                                 NumericalMethodsInfo.Instance._methods[_view.SelectedOperation][_view.SelectedMethod
                                 ],
                                 _derivationType))
                                (fx, _view.X, _view.Order, eps);
                        parametersStr = $"n={_view.Order}; x={_view.X.ToMathString()}; ε={eps.ToMathString()}";
                    }
                    else if (_view.SelectedOperation == Strings.Function_root)
                    {
                        result =
                            ((dynamic)
                             Convert.ChangeType(
                                 NumericalMethodsInfo.Instance._methods[_view.SelectedOperation][_view.SelectedMethod
                                 ],
                                 _functionRootType))
                                (fx, _view.A, _view.B, eps, _view.N);
                        parametersStr =
                            $"a={_view.A.ToMathString()}; b={_view.B.ToMathString()}; ε={eps.ToMathString()}; N={_view.N}";
                    }

                    _view.AddResult(_expressionTextProvider.Text,
                                    _view.SelectedOperation,
                                    _view.SelectedMethod,
                                    parametersStr,
                                    result.ToMathString());
                }
                catch (Exception ex)
                {
                    _exceptionsHandler.HandleException(ex);
                }
            }
            else
            {
                _errorHandler.DispalyError(
                    Strings
                    .GUI_numericalOperationButton_Click_Only_Real_mode_is_supported_in_Numerical_calculations_right_now__more_to_come_in_next_versions_ +
                    Environment.NewLine +
                    Strings.GUI_numericalOperationButton_Click__Check__Real___f_x___mode,
                    Strings.GUI_numericalOperationButton_Click_Warning_);
            }
        }