/// <summary> /// constructor accepts quantities and qs functions also /// </summary> /// <param name="x"></param> /// <param name="y"></param> /// <param name="radius"></param> public Circle(QsScalar x, QsScalar y, QsScalar radius) { if (x.ScalarType == ScalarTypes.FunctionQuantity) { xfunc = x.FunctionQuantity.Value; } else { _x = x.NumericalQuantity; } if (y.ScalarType == ScalarTypes.FunctionQuantity) { yfunc = y.FunctionQuantity.Value; } else { _y = y.NumericalQuantity; } if (radius.ScalarType == ScalarTypes.FunctionQuantity) { radfunc = radius.FunctionQuantity.Value; } else { _radius = radius.NumericalQuantity; } }
public object GetValueOrNull(string name) { if (_NamespaceType != null) { if (QsFunction.IsItFunctionSymbolicName(name)) { if (HardCodedMethods == null) { HardCodedMethods = GetQsNamespaceMethods(); } if (HardCodedMethods.ContainsKey(name)) { return(HardCodedMethods[name]); } } else { var prop = _NamespaceType.GetProperty(name, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public); if (prop != null) { return(Root.NativeToQsConvert(prop.GetValue(null, null))); } } } // try in values hash object o; Values.TryGetValue(name, out o); return(o); }
/// <summary> /// Returns a quantity from function /// </summary> /// <param name="fn"></param> /// <param name="unit"></param> /// <returns></returns> public static AnyQuantity <QsFunction> ToQuantity(this QsFunction fn, string unit = "1") { Unit sunit = Unit.Parse(unit); AnyQuantity <QsFunction> FunctionQuantity = sunit.GetThisUnitQuantity <QsFunction>(fn); return(FunctionQuantity); }
public void IsItFunctionScopeNameTest() { string name = "F#2"; // TODO: Initialize to an appropriate value bool expected = true; // TODO: Initialize to an appropriate value bool actual; actual = QsFunction.IsItFunctionSymbolicName(name); Assert.AreEqual(expected, actual); }
/// <summary> /// Decorate a native C# function with QsFunction /// </summary> /// <param name="methodInfo"></param> /// <param name="funcAttribute"></param> /// <returns></returns> public QsFunction GetQsFunctionFromTypeMethod(MethodInfo methodInfo, QsFunctionAttribute funcAttribute) { string qsNamespace = this._NamespaceType.Name; string qsFuncName = funcAttribute == null ? methodInfo.Name : funcAttribute.FunctionName; var miParameters = methodInfo.GetParameters(); int qsFuncParamCount = miParameters.Length; QsFunction QsModFunc = new QsFunction("[" + qsNamespace + "." + qsFuncName + "]", true); QsModFunc.FunctionNamespace = qsNamespace; QsModFunc.FunctionName = qsFuncName; List <QsParamInfo> prms = new List <QsParamInfo>(miParameters.Length); foreach (var miParam in miParameters) { QsParamInfo prm = new QsParamInfo(); //parameter name prm.Name = miParam.Name; var pis = miParam.GetCustomAttributes(typeof(QsParamInfoAttribute), true); if (pis.Length > 0) { prm.Type = ((QsParamInfoAttribute)pis[0]).ParameterType; } else { prm.Type = QsParamType.Value; } prms.Add(prm); } QsModFunc.Parameters = prms.ToArray(); QsModFunc.FunctionDeclaration += "("; StringBuilder sb = new StringBuilder(); foreach (var p in prms) { sb.Append(", " + p.Name); } if (sb.Length > 0) { QsModFunc.FunctionDeclaration += sb.ToString().TrimStart(',', ' '); } QsModFunc.FunctionDeclaration += ")"; QsModFunc.InternalFunctionDelegate = FormNativeFunctionDelegate(methodInfo); return(QsModFunc); }
public void FormFunctionSymbolicNameTest() { string functionName = "f"; // TODO: Initialize to an appropriate value string[] paramNames = { "u", "v" }; // TODO: Initialize to an appropriate value string expected = "f#2_u_v"; // TODO: Initialize to an appropriate value string actual; actual = QsFunction.FormFunctionSymbolicName(functionName, paramNames); Assert.AreEqual(expected, actual); }
public void ContainsParameterTest() { QsFunction target = GetTestFunction("TestContains", "x", "Gh", "FyI", "Df"); Assert.AreEqual <bool>(true, target.ContainsParameter("gh")); Assert.AreEqual <bool>(true, target.ContainsParameter("fyi")); Assert.AreEqual <bool>(false, target.ContainsParameter("fluid")); Assert.AreEqual <bool>(false, target.ContainsParameter("do")); Assert.AreEqual <bool>(true, target.ContainsParameter("x")); }
public static QsVector Func(QsFunction f, DimensionlessQuantity <double> from, DimensionlessQuantity <double> to) { var increment = (to - from) / (40).ToQuantity(); QsVector v = new QsVector(40); for (AnyQuantity <double> dt = from; dt <= to; dt += increment) { v.AddComponent(f.Invoke(dt).ToScalar()); } return(v); }
public void ContainsParametersTest() { QsFunction target = GetTestFunction("TestContains", "fluid", "x", "h", "u", "s", "v"); Assert.AreEqual <bool>(false, target.ContainsParameters("gh")); Assert.AreEqual <bool>(true, target.ContainsParameters("fluid", "x")); Assert.AreEqual <bool>(false, target.ContainsParameters("fluid", "y")); Assert.AreEqual <bool>(true, target.ContainsParameters("fluid", "u", "x", "s", "v")); Assert.AreEqual <bool>(true, target.ContainsParameters("h", "s")); Assert.AreEqual <bool>(true, target.ContainsParameters("u", "v")); }
/// <summary> /// The method sum all elements in the sequence between the supplied indexes. /// Correspondes To: S[i++k] /// </summary> public QsValue SumElements(int fromIndex, int toIndex) { if (this.Parameters.Length > 0) { // this is a call to form symbolic element // like g[n](x) ..> x^n // and calling g[0++2] // the output should be x^0 + x^1 + x^2 // and be parsed into function (QsFunction) string porma = string.Empty; // the parameters separated by comma ',' foreach (var prm in this.Parameters) { porma += prm.Name + ", "; } porma = porma.TrimEnd(',', ' '); string FunctionBody = JoinElementsWithOperation(fromIndex, toIndex, "+"); string FunctionDeclaration = "_(" + porma + ") = " + FunctionBody; QsFunction qs = QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, FunctionDeclaration); return(new QsScalar(ScalarTypes.FunctionQuantity) { FunctionQuantity = qs.ToQuantity() }); } else { FixIndices(ref fromIndex, ref toIndex); QsValue Total = GetElementValue(fromIndex); for (int i = fromIndex + 1; i <= toIndex; i++) { Total = Total + GetElementValue(i); } return(Total); } }
// //You can use the following additional attributes as you write your tests: // //Use ClassInitialize to run code before running the first test in the class //[ClassInitialize()] //public static void MyClassInitialize(TestContext testContext) //{ //} // //Use ClassCleanup to run code after all tests in a class have run //[ClassCleanup()] //public static void MyClassCleanup() //{ //} // //Use TestInitialize to run code before running each test //[TestInitialize()] //public void MyTestInitialize() //{ //} // //Use TestCleanup to run code after each test has run //[TestCleanup()] //public void MyTestCleanup() //{ //} // #endregion public QsFunction GetTestFunction(string function, params string[] paramNames) { List <QsParamInfo> lpi = new List <QsParamInfo>(); foreach (string prm in paramNames) { lpi.Add(new QsParamInfo() { Name = prm, Type = QsParamType.Value }); } QsFunction target = new QsFunction(function); target.Parameters = lpi.ToArray(); return(target); }
/// <summary> /// Take the average of the sequence. /// Corresponds To: S[i!!k] /// </summary> /// <param name="fromIndex"></param> /// <param name="toIndex"></param> /// <returns></returns> public QsValue Average(int fromIndex, int toIndex) { var n = toIndex - fromIndex + 1; if (this.Parameters.Length > 0) { // this is a call to form symbolic element // like g[n](x) ..> x^n // and calling g[0++2] // the output should be x^0 + x^1 + x^2 // and be parsed into function (QsFunction) string porma = string.Empty; // the parameters separated by comma ',' foreach (var prm in this.Parameters) { porma += prm.Name + ", "; } porma = porma.TrimEnd(',', ' '); string FunctionBody = "(" + JoinElementsWithOperation(fromIndex, toIndex, "+") + ")/" + n.ToString(CultureInfo.InvariantCulture); string FunctionDeclaration = "_(" + porma + ") = " + FunctionBody; QsFunction qs = QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, FunctionDeclaration); return(qs); } else { FixIndices(ref fromIndex, ref toIndex); var tot = SumElements(fromIndex, toIndex); var count = new QsScalar { NumericalQuantity = Qs.ToQuantity((double)n) }; return(tot / count); } }
/// <summary> /// It tries to get the value of the given key. /// </summary> /// <param name="name"></param> /// <returns></returns> public object GetValue(string name) { if (_NamespaceType != null) { if (QsFunction.IsItFunctionSymbolicName(name)) { if (HardCodedMethods == null) { HardCodedMethods = GetQsNamespaceMethods(); } if (HardCodedMethods.ContainsKey(name)) { return(HardCodedMethods[name]); } } else { var prop = _NamespaceType.GetProperty(name, BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public); if (prop != null) { return(Root.NativeToQsConvert(prop.GetValue(null, null))); } } } // try in values hash object o; Values.TryGetValue(name, out o); if (o == null) { throw new QsVariableNotFoundException("Variable '" + name + "' not found in '" + this.Name + "' namespace."); } return(o); }
/// <summary> /// Gets the members of the QsNamespace or (static class ) that hold the hard coded functions and properties. /// </summary> /// <param name="namespaceType"></param> /// <returns></returns> private Dictionary <string, object> GetQsNamespaceMethods() { // The namespace is a static class with public visibility to its static members. var methods = _NamespaceType.GetMethods( BindingFlags.IgnoreCase | BindingFlags.Static | BindingFlags.Public /*| BindingFlags.InvokeMethod */ ); Dictionary <string, object> CodedMembers = new Dictionary <string, object>(System.StringComparer.OrdinalIgnoreCase); /* * var FilteredMethods = from m in methods * where * m.IsSpecialName == false * * && m.ReturnType.IsArray == false && * (m.ReturnType.BaseType == typeof(QsValue) || m.ReturnType == typeof(QsValue) || * m.ReturnType == typeof(string) || m.ReturnType.IsValueType == true) * * select m; */ var FilteredMethods = from m in methods where m.IsSpecialName == false select m; foreach (var member in FilteredMethods) { var method = ((MethodInfo)member); if (!method.IsSpecialName) //because properies getters are methods also :S { ParameterInfo[] mps = method.GetParameters(); int paramCount = mps.Length; var fAttributes = method.GetCustomAttributes(typeof(QsFunctionAttribute), false); QsFunctionAttribute funcAttribute = null; string method_name = string.Empty; string methodTrueName = string.Empty; if (fAttributes.Length > 0) { funcAttribute = (QsFunctionAttribute)fAttributes[0]; // if the attribute were found treat the function as namedargument function that is not default function. method_name = funcAttribute.FunctionName; if (funcAttribute.DefaultScopeFunction == false) { // alter the name so it includes the parameters also string[] ptext = (from p in mps select p.Name).ToArray(); methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, ptext); } else { // don't use special parameter symbolic naming. methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, paramCount); } CodedMembers.Add(methodTrueName, GetQsFunctionFromTypeMethod(method, funcAttribute)); } else { method_name = method.Name; methodTrueName = QsFunction.FormFunctionSymbolicName(method_name, paramCount); CodedMembers.Add(methodTrueName, GetQsFunctionFromTypeMethod(method, null)); } } } return(CodedMembers); }
/// <summary> /// Gets the element quantity and employ cach /// </summary> /// <param name="index"></param> /// <returns></returns> public QsValue GetElementValue(int index) { QsValue val; if (CachingEnabled) { if (CachedValues.TryGetValue(index, out val)) { return(val); } } if (this.Parameters.Length > 0) { // this is a call to form symbolic element // like g[n](x) ..> x^n // and calling g[2] // the output should be x^2 // and be parsed into function (QsFunction) var e = GetElement(index); string se_text = e.ElementDeclaration.Replace("$" + this.SequenceIndexName, "`"); se_text = se_text.Replace(this.SequenceIndexName, index.ToString(CultureInfo.InvariantCulture)); se_text = se_text.Replace("`", "$" + this.SequenceIndexName); if (!string.IsNullOrEmpty(SequenceRangeStartName)) { se_text = se_text.Replace("$" + SequenceRangeStartName, "`"); se_text = se_text.Replace(SequenceRangeStartName, StartIndex.ToString(CultureInfo.InvariantCulture)); se_text = se_text.Replace("`", "$" + SequenceRangeStartName); } if (!string.IsNullOrEmpty(SequenceRangeEndName)) { se_text = se_text.Replace("$" + SequenceRangeEndName, "`"); se_text = se_text.Replace(SequenceRangeEndName, EndIndex.ToString(CultureInfo.InvariantCulture)); se_text = se_text.Replace("`", "$" + SequenceRangeEndName); } var FunctionBody = se_text; string porma = string.Empty; // the parameters separated by comma ',' foreach (var prm in this.Parameters) { porma += prm.Name + ", "; } porma = porma.TrimEnd(',', ' '); string FunctionDeclaration = "_(" + porma + ") = " + FunctionBody; QsFunction qs = QsFunction.ParseFunction(QsEvaluator.CurrentEvaluator, FunctionDeclaration); return(new QsScalar(ScalarTypes.FunctionQuantity) { FunctionQuantity = qs.ToQuantity() }); } else { val = GetElement(index).Execute(index); } if (CachingEnabled) { CachedValues[index] = val; } return(val); }