public GameProcessViewModel() { _expression = new MathExpression(1, 10, true, false, false, false); _question = new Question(_expression); _listOfAnswers = new List <int>(_question.getListOfAnswers()); getQuestion(); }
private double[][] GenerateAMatrix(int N, MathExpression tFunc, MathExpression bFunc, MathExpression sigmaFunc) { double h = 1.0 / N; double[][] res = new double[N][]; for (int i = 0; i < N; i++) { res[i] = new double[N]; for (int j = 0; j < N; j++) { if (i != N - 1) { if (i == j) { res[i][j] = (1.0 / h) * (tFunc.Calculate(h * (i + 1) - (h / 2.0)) + tFunc.Calculate(h * (i + 1) + (h / 2.0))) + (h / 3.0) * (sigmaFunc.Calculate(h * (i + 1) - (h / 2.0)) + sigmaFunc.Calculate(h * (i + 1) + (h / 2.0))) + (1.0 / 2.0) * (bFunc.Calculate(h * (i + 1) - (h / 2.0)) - bFunc.Calculate(h * (i + 1) + (h / 2.0))); } else if (j == i + 1) { res[i][j] = -(1.0 / h) * tFunc.Calculate(h * (i + 1) + (h / 2.0)) + (1.0 / 2.0) * bFunc.Calculate(h * (i + 1) + (h / 2.0)) + (h / 6.0) * sigmaFunc.Calculate(h * (i + 1) + (h / 2.0)); } else if (j == i - 1) { res[i][j] = -(1.0 / h) * tFunc.Calculate(h * (i + 1) - (h / 2.0)) - (1.0 / 2.0) * bFunc.Calculate(h * (i + 1) - (h / 2.0)) + (h / 6.0) * sigmaFunc.Calculate(h * (i + 1) - (h / 2.0)); } else { res[i][j] = 0; } } else { if (j < N - 2) { res[i][j] = 0; } else if (j == N - 2) { res[i][j] = -(1.0 / h) * tFunc.Calculate(h * (i + 1) - (h / 2.0)) - (1.0 / 2.0) * bFunc.Calculate(h * (i + 1) - (h / 2.0)) + (h / 6.0) * sigmaFunc.Calculate(h * (i + 1) - (h / 2.0)); } else if (j == N - 1) { res[i][j] = (1.0 / h) * tFunc.Calculate(h * (i + 1) - (h / 2.0)) + (1.0 / 2.0) * bFunc.Calculate(h * (i + 1) - (h / 2.0)) + (h / 3.0) * sigmaFunc.Calculate(h * (i + 1) - (h / 2.0)); } } } } return(res); }
public static double CalculateWithAccuracy(double a, double b, MathExpression function, double epsilon, params Var[] variables) { List <double> Xk = new List <double>() { -0.8611363, -0.3399810, 0.3399810, 0.8611363 }; List <double> Ck = new List <double>() { 0.3478548, 0.6521452, 0.6521452, 0.3478548 }; double result; int n = 1; double newResult = Calculate(a, b, n, function, variables); do { n *= 2; result = newResult; newResult = Calculate(a, b, n, function, variables); }while (System.Math.Abs(newResult - result) > epsilon); return(newResult); }
public static double Calculate(double a, double b, int amountOfPartitions, MathExpression function, params Var[] variables) { List <double> Xk = new List <double>() { -0.8611363, -0.3399810, 0.3399810, 0.8611363 }; List <double> Ck = new List <double>() { 0.3478548, 0.6521452, 0.6521452, 0.3478548 }; double result = 0; double step = (b - a) / amountOfPartitions; for (int i = 0; i < amountOfPartitions; i++) { double a_new = a + step * i; double b_new = a + step * (i + 1); double sum = 0; for (int j = 0; j < Xk.Count; j++) { variables[0].Value = (a_new + b_new) / 2.0 + (b_new - a_new) / 2.0 * Xk[j]; sum += Ck[j] * function.Calculate(variables); } result += sum * (b_new - a_new) / 2.0; } return(result); }
public async Task TestMathExpression_ApiUriShouldWork() { string controller = "api/calculator/evaluateexpression"; var mathExpression = new MathExpression() { Expression = "1+2" }; using (var httpClient = new HttpClient()) { httpClient.BaseAddress = new Uri(baseUri); httpClient.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await httpClient.PostAsJsonAsync(controller, mathExpression); Assert.IsNotNull(response); Assert.IsTrue(response.IsSuccessStatusCode); var x = await response.Content.ReadAsAsync <MathExpression>(); Assert.IsNotNull(x); Assert.IsNotNull(x.Key); Assert.AreEqual(3, x.Key); } }
/// <summary> /// Optimizes the provided expression using an <see cref="OptimizationContext{TSettings}"/> /// created with <see cref="OptimizationContext.CreateDefault(DefaultOptimizationSettings?, IEnumerable{IOptimizationPass{DefaultOptimizationSettings}})"/> /// </summary> /// <param name="expr">the expression to optimize</param> /// <returns>the optimized expression</returns> public override MathExpression Optimize(MathExpression expr) { var ctx = OptimizationContext.CreateDefault(OptimizerSettings, OptimizerPasses); ctx.SetParentDataContext(SharedDataStore); return(ctx.Optimize(expr)); }
public void SolveTest() { Assert.AreEqual(MathExpression.Solve("((2+2)*2+2*(2+2*(2+2))+2*2)+2+2*2*2+2"), 44); Assert.AreEqual(MathExpression.Solve("2+2*(2+2*2+(2+2*(2+2)))"), 34); Assert.AreEqual(MathExpression.Solve("(((25+227)/2)+134)*2+((48+2)*(2+2))"), 720); Assert.AreEqual(MathExpression.Solve("4*2+3-78+16*(21*3-7)+88/4"), 851); }
public void Define(string variable, MathExpression expression) { try { _lock.EnterWriteLock(); // Make sure the variable isn't refering to itself. if (_variableFinder.HasVariableDefined(expression, this, variable)) { string message = string.Format("Variable '{0}' is refering to itself recursively.", variable); throw new MathExpressionException(message); } if (_lookup.ContainsKey(variable)) { _lookup[variable] = expression; } else { _lookup.Add(variable, expression); } } finally { _lock.ExitWriteLock(); } }
public void CompileVariable(MathExpression expr, Type expectType, string paramName, object parameter, object result) { var context = CompilationContext.CreateWith(new DefaultLinqExpressionCompilerSettings { ExpectReturn = expectType, }, new DefaultLinqExpressionCompiler <DefaultLinqExpressionCompilerSettings>()); var objParam = Expression.Parameter(typeof(object)); var var = Expression.Variable(expectType); context.Settings.ParameterMap.Add(new VariableExpression(paramName), var); var fn = Expression.Lambda <Func <object, object> >( Expression.Block( new[] { var }, Expression.Assign(var, Expression.Convert(objParam, expectType)), Expression.Convert( context.Compile(expr), typeof(object) ) ), objParam ).Compile(); Assert.Equal(fn(parameter), result); }
public void CriacaoMathExpressionTest(object[] actual, double expected) { var aux = new MathExpression(actual[0].ToString()); var x = Convert.ToDouble(actual[1]); Assert.AreEqual(expected, aux.F(x)); }
public static MathExpression GetExpression(string entry, Tokenizer tokenizer, Data data) { var tokens = tokenizer.Tokenize(entry); List <Expression> exprs = new List <Expression>(); foreach (var token in tokens) { if (Tokenizer.isValue(token.type)) { if (token.type == TokenType.ID) { exprs.Add(new Reference(token.value, data)); } else { exprs.Add(new Constant(token.value)); } } else if (Tokenizer.isOperator(token.type)) { exprs.Add(new Operator(token.type)); } } MathExpression math = new MathExpression(exprs); return(math); }
// Recursivlly go down the tree // IMPORTANT dont forget to return :) // otherway Your expression will unfold which will result with unpredicted behaviour private double ResolveTree(double result, MathExpression expressionTree, double extras) { if (expressionTree == null) { return(result + extras); } if (HasPriority(expressionTree.Operation)) { extras = MakeOperation(extras, expressionTree.Value, expressionTree.Operation); return(ResolveTree(result, expressionTree.Next, extras)); } // if next operation has priority over current one // assing current value to extras and move to next expression if (expressionTree.Next != null && HasPriority(expressionTree.Next.Operation)) { extras = expressionTree.Value; return(ResolveTree(result, expressionTree.Next, extras)); } result = MakeOperation(result, expressionTree.Value, expressionTree.Operation) + extras; extras = 0.0; return(ResolveTree(result, expressionTree.Next, extras)); }
public void Test_Printing_Instructions_For_Long_Expressions() { var expression = new MathExpression("7/2+14*9-5-15*500"); var instructions = new StringBuilder(); instructions.AppendLine("PUSH 7"); instructions.AppendLine("PUSH 2"); instructions.AppendLine("DIVIDE"); instructions.AppendLine("PUSH 14"); instructions.AppendLine("ADD"); instructions.AppendLine("PUSH 9"); instructions.AppendLine("MULTIPLY"); instructions.AppendLine("PUSH 5"); instructions.AppendLine("SUBTRACT"); instructions.AppendLine("PUSH 15"); instructions.AppendLine("SUBTRACT"); instructions.AppendLine("PUSH 500"); instructions.AppendLine("MULTIPLY"); instructions.AppendLine("PRINT"); StringAssert.AreEqualIgnoringCase( expression.createProgramInstructions().ToString(), instructions.ToString() ); }
private static bool CanAddArithmaticOperator(MathExpression expression) { return(!(expression.Expression.EndsWith("+") || expression.Expression.EndsWith("-") || expression.Expression.EndsWith("/") || expression.Expression.EndsWith("*"))); }
public double NewtonRaphson() { if (DerivadaFuncao == null) { throw new Exception("Função derivada necessária"); } if (X == null) { throw new Exception("Valor de X necessário"); } var funcaoLinha = new MathExpression(DerivadaFuncao); var x = X; double fx; var validador = 0; do { x -= _math.F(x) / funcaoLinha.F(x); fx = _math.F(x); validador++; if (validador > short.MaxValue * 1000) { throw new Exception("Não conseguimos encontrar o valor"); } } while (Math.Abs(fx) >= Precisao); return(x); }
public void Test_Expression_With_Empty_Operations() { var expression = new MathExpression("5"); Assert.AreEqual(expression.FirstValue, 5); Assert.AreEqual(expression.Operations.Count, 0); }
private static string AppendOrReplaceArithmaticOperator(MathExpression expression) { return (CanAddArithmaticOperator(expression) ? string.Format("{0}{1}", expression.Expression, expression.Key) : ReplaceOldOperatorWithNew(expression)); }
public void BinaryCombinerLiteralCombinerPasses(MathExpression input, MathExpression expect) { var context = OptimizationContext.CreateWith(new DefaultOptimizationSettings(), new BinaryExpressionCombinerPass(), new LiteralCombinerPass()); var actual = context.Optimize(input); Assert.Equal(expect, actual); }
public void ExponentConstantReductionPass(MathExpression input, MathExpression expect) { var context = OptimizationContext.CreateWith(null, new BuiltinExponentConstantReductionPass()); var actual = context.Optimize(input); Assert.Equal(expect, actual); }
public void LiteralCombinerPass(MathExpression input, MathExpression expect) { var context = OptimizationContext.CreateWith(null, new LiteralCombinerPass()); var actual = context.Optimize(input); Assert.Equal(expect, actual); }
public OneDimensionDeriveItem(int initialValue, double stepValue, int valueAmplitude, string variableName, MathExpression expression) { InitialValue = initialValue; StepValue = stepValue; Expression = expression; elementCount = valueAmplitude * 2; VariableName = variableName; }
public InputData(string mu, string beta, string sigma, string f, double alpha, double eta) { _mu = new MathExpression(mu); _beta = new MathExpression(beta); _sigma = new MathExpression(sigma); _f = new MathExpression(f); Alpha = alpha; Eta = eta; }
public void Test_Expression_With_One_Operation() { var expression = new MathExpression("10-3"); Assert.AreEqual(expression.FirstValue, 10); var operation = new MathOperation(Operator.Subtract, 3); Assert.AreEqual(expression.Operations.FirstOrDefault(), operation); }
public async Task <ActionResult> DeleteConfirmed(int id) { MathExpression mathExpression = await db.MathExpressions.FindAsync(id); db.MathExpressions.Remove(mathExpression); await db.SaveChangesAsync(); return(RedirectToAction("Index")); }
public void TestCSharpMathSolverCreation() { IExpressionProvider <MathExpression> provider = new DefaultExpressionTreeProvider(new DoubleValueProvider()); string expression = "1+2/3+5"; MathExpression targetExpression = BuildTree(); MathExpression mathExpression = provider.GetExpressions(expression); Assert.AreEqual(targetExpression, mathExpression); }
public double Solve(string expression) { MathExpression expressionTree = expressionTreeProvider.GetExpressions(expression); //skip root and assign its value to extras double result = 0.0; result = ResolveTree(result, expressionTree.Next, expressionTree.Value); return(result); }
public ZeroFuncao(ZeroFuncaoDto data) { Funcao = data.Funcao; DerivadaFuncao = data.DerivadaFuncao; X = data.X; X2 = data.X2; _math = new MathExpression(Funcao); Precisao = data.Precisao != 0 ? data.Precisao : 0.001; Ponto = data.Ponto; }
private void OnEqualPressCommandExecute(object p) { if (CurrentExpression.Content != "") { CurrentExpression.CalculateResult(); ExpressionHistory.Add(CurrentExpression); OnPropertyChanged("CurrentExpression"); CurrentExpression = new MathExpression(); } }
public MainWindowViewModel() { ButtonPressCommand = new RelayCommand(OnButtonPressCommandExecute, CanButtonPressCommandExecute); EqualPressCommand = new RelayCommand(OnEqualPressCommandExecute, CanEqualPressCommandExecute); ClearPressCommand = new RelayCommand(OnClearPressCommandExecute, CanClearPressCommandExecute); DeletePressCommand = new RelayCommand(OnDeletePressCommandExecute, CanDeletePressCommandExecute); DotPressCommand = new RelayCommand(OnDotPressCommandExecute, CanDotPressCommandExecute); ExpressionHistory = new ObservableCollection <MathExpression>(); CurrentExpression = new MathExpression(); }
public List <double> Generate(double[] mesh) { MathExpression fFunc = new MathExpression(_presizeFunction); List <double> results = new List <double>(); for (int i = 0; i < mesh.Length; i++) { results.Add(fFunc.Calculate(mesh[i])); } return(results); }
public MathExpression EvaluateExpression(MathExpression mathExpression) { try { return(MathHelper.EvaluateExpression(mathExpression)); } catch (Exception ex) { return(null); } }
protected UnaryExpression(MathExpression expression) { _expression = expression; }
/// <summary> /// Returns instance of InterpolativeMathFunction with automatically generated derivations. /// </summary> /// <param name="expression">Interpreted math function of two real variables i.e. "x^2 + y^2".</param> /// <returns> /// Instance of class if mathExpression is in correct format, othervise /// returns null; /// </returns> public static InterpolativeMathFunction FromExpression(MathExpression expression) { // TODO: osetrit vynimky pre neplatne vstupy var f = expression.Interpret(); var dx = expression.InterpretMathDifferentiation (expression.Variables[0]); var dy = expression.InterpretMathDifferentiation (expression.Variables[1]); var dxy = expression.InterpretMathDifferentiation (expression.Variables[0], expression.Variables[1]); return new InterpolativeMathFunction(f, dx, dy, dxy); }
protected BinaryExpression(MathExpression left, MathExpression right) { _left = left; _right = right; }