/// <summary> /// Differentiate operation for function. /// </summary> /// <param name="value">object of <see cref="QsScalar"/> that hold <see cref="AnyQuantity<SymbolicVariable>"/></param> /// <returns></returns> public override QsValue DifferentiateOperation(QsValue value) { QsScalar sval = (QsScalar)value; if (sval.ScalarType == ScalarTypes.SymbolicQuantity) { var dsv = sval.SymbolicQuantity.Value; string fname = "_"; string WholeFunction = string.Empty; if (this.FunctionBodyToken[0].TokenClassType == typeof(CurlyBracketGroupToken)) { // vector differentiation // take every term in the vector and differentiate it var vcs = QsVar.VectorComponents(this.FunctionBodyToken[0]); StringBuilder sc = new StringBuilder(); sc.Append(fname + "(" + RemoveRedundantParameters(this.ParametersNames) + ") = "); sc.Append("{ "); foreach (var c in vcs) { SymbolicVariable nsv = SymbolicVariable.Parse(c); int times = (int)dsv.SymbolPower; while (times > 0) { nsv = nsv.Differentiate(dsv.Symbol); times--; } sc.Append(nsv.ToString()); sc.Append(" "); } sc.Append("}"); WholeFunction = sc.ToString(); } else { SymbolicVariable nsv = ToSymbolicVariable(); int times = (int)dsv.SymbolPower; while (times > 0) { nsv = nsv.Differentiate(dsv.Symbol); times--; } WholeFunction = fname + "(" + RemoveRedundantParameters(this.ParametersNames) + ") = " + nsv.ToString(); } return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction)); } else { return(base.DifferentiateOperation(value)); } }
/// <summary> /// Take the value and operation in text and return the current function operationed by value. /// </summary> /// <param name="value"></param> /// <param name="operation"></param> /// <returns></returns> private QsFunction FOperation(QsValue value, string operation) { if (value is QsFunction) { QsFunction fn2 = (QsFunction)value; string fParameters = RemoveRedundantParameters(this.ParametersNames.Union(fn2.ParametersNames).ToArray()); string thisFunctionBody = this.FunctionBody; foreach (string p in this.ParametersNames) { thisFunctionBody = thisFunctionBody.Replace(p, "$" + p); } string targetFunctionBody = fn2.FunctionBody; foreach (string p in fn2.ParametersNames) { targetFunctionBody = targetFunctionBody.Replace(p, "$" + p); } // form the expressions that will be parsed. string fpt = "(" + thisFunctionBody + ")" + operation + "(" + targetFunctionBody + ")"; fpt = fpt.Replace("!", "__FAC__"); // replacing the ! sign with __FAC__ to include the '!' sign into the calculations {because '!' is operator in parsing so it doesn't enter the algebraic calculations} //evaulate fpt try { QsScalar sc = (QsScalar)QsEvaluator.CurrentEvaluator.SilentEvaluate(fpt); string FuncBody = sc.SymbolicQuantity.Value.ToString().Replace("__FAC__", "!"); string WholeFunction = "_(" + fParameters + ") = " + FuncBody; return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction)); } catch (QsIncompleteExpression) { // something happened make the operation in old fashion string WholeFunction; Token FunctionToken = JoinFunctionsArrayTokensWithOperation(operation, out WholeFunction, this, fn2); return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, WholeFunction, FunctionToken)); } } else if (value is QsScalar) { QsScalar svl = (QsScalar)value; var fname = "_"; var fbody = this.FunctionBody; if (svl.ScalarType == ScalarTypes.SymbolicQuantity) { fbody = "(" + fbody + ")" + operation + "(" + svl.SymbolicQuantity.Value.ToString() + ")"; } else if (svl.ScalarType == ScalarTypes.NumericalQuantity) { fbody = "(" + fbody + ")" + operation + svl.NumericalQuantity.Value.ToString(); } else if (svl.ScalarType == ScalarTypes.RationalNumberQuantity) { fbody = "(" + fbody + ")" + operation + svl.RationalQuantity.Value.Value.ToString(); } else if (svl.ScalarType == ScalarTypes.FunctionQuantity) { fbody = "(" + fbody + ")" + operation + "(" + svl.FunctionQuantity.Value.FunctionBody + ")"; } else { throw new QsException("Operation '" + operation + "' for the target scalar type (" + svl.ScalarType + ") is not supported"); } QsScalar fb = SymbolicVariable.Parse(fbody).ToQuantity().ToScalar(); string FuncBody = string.Empty; if (fb.ScalarType == ScalarTypes.SymbolicQuantity) { FuncBody = fb.SymbolicQuantity.Value.ToString().Replace("__FAC__", "!"); } else { FuncBody = fb.ToExpressionParsableString(); } string[] functionParametersArray = this.ParametersNames; // this is the available parameters for the original function. if (svl.ScalarType == ScalarTypes.SymbolicQuantity) { List <string> newParametersList = new List <string>(functionParametersArray); newParametersList.AddRange(svl.SymbolicQuantity.Value.InvolvedSymbols); functionParametersArray = newParametersList.ToArray(); } if (svl.ScalarType == ScalarTypes.FunctionQuantity) { List <string> newParametersList = new List <string>(functionParametersArray); newParametersList.AddRange(svl.FunctionQuantity.Value.ParametersNames); functionParametersArray = newParametersList.ToArray(); } var f = fname + "(" + RemoveRedundantParameters(functionParametersArray) + ") = " + FuncBody; return(QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, f)); } else { throw new NotImplementedException(); } }