static void Main(string[] args) { // ScalarFunction x = "x"; ScalarFunction y = "y"; ScalarFunction a = "a"; ScalarFunction b = "b"; ScalarFunction c = "c"; ScalarFunction d = "d"; ScalarFunction i = "i"; ScalarFunction j = "j"; MatrixFunction m = NewMatrix(new Matrix <ScalarFunction>( new[] { new ScalarFunction[] { a, b }, new ScalarFunction[] { c, d } })); VectorFunction v = NewColumnVector(new ScalarFunction[] { x, y }); VectorFunction r = NewColumnVector(new ScalarFunction[] { i, j }); BinaryFunction k = MatrixMethods.RotationMethod(m, v, r); k = k.Calculate(); //Console.WriteLine(((a * i + c * j) / (a * a + c * c)).Calculate()); //var sqrt = op_Exponentiation(op_Exponentiation(a, 2) + op_Exponentiation(c, 2), 0.5); //var d_y = ((a * j - c * i) / (a * d - c * b)) * (a * b + c * d); //var gg = ((x * (a * a + c * c)) + y) / sqrt == (a * i + c * j) / sqrt; //var gg2 = NewScalarFind(x, gg).Calculate(); //var gg3 = gg2.Calculate(NewScalarFind(y, y == d_y)); Console.ReadKey(); }
public override object VisitScalarFunctionCall([NotNull] PostgresParser.ScalarFunctionCallContext context) { ScalarFunction res; if (context.scalarFunctionName().SUM() != null) res = new SumAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().COUNT() != null) res = new CountAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().AVG() != null) res = new AvgAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().MIN() != null) res = new MinAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().MAX() != null) res = new MaxAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().STDDEV_SAMP() != null) res = new StDevAggregationFunction(context.scalarFunctionName().GetText()); else if (context.scalarFunctionName().LINREG() != null) res = new LinRegAggregationFunction(context.scalarFunctionName().GetText()); else res = new ScalarFunction(context.scalarFunctionName().GetText()); if (context.functionArgs() != null) foreach (var exp in (List<Expression>)Visit(context.functionArgs())) res.AddChild(exp); return res; }
public static EntityClassDefinition CreateEntity(this DapperProject project, ScalarFunction scalarFunction) { var definition = new EntityClassDefinition { Namespaces = { "System" }, Namespace = project.Database.HasDefaultSchema(scalarFunction) ? project.GetEntityLayerNamespace() : project.GetEntityLayerNamespace(scalarFunction.Schema), AccessModifier = AccessModifier.Public, Name = scalarFunction.GetEntityName(), Constructors = { new ClassConstructorDefinition(AccessModifier.Public) } }; if (!string.IsNullOrEmpty(scalarFunction.Description)) { definition.Documentation.Summary = scalarFunction.Description; } var selection = project.GetSelection(scalarFunction); definition.Implements.Add("IEntity"); if (selection.Settings.SimplifyDataTypes) { definition.SimplifyDataTypes(); } return(definition); }
public void CheckOperators() { ScalarFunction x = "x"; ScalarFunction y = "y"; ScalarFunction z = "z"; Assert.AreEqual(x + y, x + y); Assert.AreEqual(y + x, y + x); Assert.AreEqual(x + x, 2 * x); Assert.AreEqual(y + y, 2 * y); Assert.AreEqual(0 + x, x); Assert.AreEqual(x + 0, x); Assert.AreEqual(-y + x, x - y); Assert.AreEqual(x + -y, x - y); Assert.AreEqual(-x + 0, -x); Assert.AreEqual(0 + -x, -x); Assert.AreEqual(0 - x, -x); Assert.AreEqual((x - y) + z, (x + z) - y); Assert.AreEqual((x + -y) + z, (x + z) - y); Assert.AreEqual(-x + y + z, y + z - x); Assert.AreEqual(-x - y + z, z - (x + y)); Assert.AreEqual(-x + -y + z, z - (x + y)); Assert.AreEqual(x + y - z, x + y - z); Assert.AreEqual(x - y - z, x - (y + z)); Assert.AreEqual(-x + -y + -z, -(x + y + z)); Assert.AreEqual(x * x, op_Exponentiation(x, 2)); Assert.AreEqual(x * y, x * y); Assert.AreEqual(y * x, x * y); Assert.AreEqual(-x * y, -(y * x)); Assert.AreEqual(x * -y, -(x * y)); Assert.AreEqual(-x * -y, x * y); }
/// <summary> /// ctor. /// </summary> public LxNormQuadrature(DGField owner, ScalarFunction func, Func <double[], double, double, double> Map, ICompositeQuadRule <QuadRule> rule) : base(new int[] { 1 }, owner.Basis.GridDat, rule) // { m_func = func; m_Owner = owner; m_Map = Map; }
public void Heat() { ScalarFunction x = "x"; ScalarFunction y = "y"; ScalarFunction z = x + y; double? e = z; double? c = z.Calculate("x" == NewConstant(9) & "y" == NewConstant(10)); }
public override object VisitUdfFunctionCall([NotNull] PostgresParser.UdfFunctionCallContext context) { var res = new ScalarFunction((Identifier)Visit(context.uid())); if (context.functionArgs() != null) foreach (var exp in (List<Expression>)Visit(context.functionArgs())) res.AddChild(exp); return res; }
/// <summary> /// Variant of /// <see cref="LxError(ScalarFunction, Func{double, double, double}, ICompositeQuadRule{QuadRule})"/> /// that computes the cell-local Lx norm (and does thus not include MPI /// communication) /// </summary> /// <param name="function"> /// Optional: Reference function for error computation. If null, zero /// is taken as the reference function /// </param> /// <param name="quadRule"> /// composite quadrature rule. /// </param> /// <param name="Map"> /// Arbitrary mapping applied to the values of this field and /// <paramref name="function"/> at some point, which is finally /// integrated. E.g., the mapping for an L2-error would be /// \f$ (a,b) => (a - b)^2 \f$, where \f$ a \f$ is the value of this /// field at some point \f$ \vec{x} \f$ and \f$ b \f$ is the value of /// <paramref name="function"/> at \f$ \vec{x} \f$. /// </param> /// <returns> /// The cell-local Lx norm of this field minus /// <paramref name="function"/>, approximated by the quadrature rule /// <paramref name="quadRule"/> /// </returns> public double[] LocalLxError(ScalarFunction function, Func <double[], double, double, double> Map, ICompositeQuadRule <QuadRule> quadRule) { using (new FuncTrace()) { LocalLxNormQuadrature quacdrature = new LocalLxNormQuadrature(this, function, Map, quadRule); quacdrature.Execute(); return(quacdrature.LocalLxNorms); } }
private void ImportDescription(DbConnection connection, ScalarFunction scalarFunction) { if (ImportSettings.ImportMSDescription) { foreach (var extendProperty in connection.GetMsDescriptionForDbObject(scalarFunction)) { scalarFunction.Description = string.Concat(extendProperty.Value); } } }
private void ImportExtendedProperties(DbConnection connection, ScalarFunction scalarFunction) { foreach (var name in DatabaseImportSettings.ExtendedProperties) { foreach (var extendedProperty in connection.GetExtendedProperties(scalarFunction, name)) { // todo: Remove this token if (name == "MS_Description") scalarFunction.Description = extendedProperty.Value; } } }
/// <summary> /// This call computes an integral measure which may depend on /// this <see cref="DGField"/> an the given <paramref name="function"/>; /// This is a collective call, it must be invoked by all /// MPI processes within the communicator; internally, it invokes MPI_Allreduce; /// </summary> /// <param name="function"> /// Optional: Reference function for error computation. If null, zero /// is taken as the reference function /// </param> /// <param name="rule"> /// composite quadrature rule. /// </param> /// <param name="Map"> /// Arbitrary mapping applied to the values of this field and /// <paramref name="function"/> at some point, which is finally integrated. /// E.g., the mapping for an L2-error would be \f$ (\vec{x},a,b) => (a - b)^2 \f$, /// where \f$ a \f$ is the value of this field at some point \f$ \vec{x} \f$ and /// \f$ b \f$ is the value of <paramref name="function"/> at \f$ \vec{x} \f$. /// </param> /// <returns> /// on all invoking MPI processes, the L2 norm of /// this field minus <paramref name="function"/>, approximated by the /// quadrature rule <paramref name="rule"/> /// </returns> public double LxError(ScalarFunction function, Func <double[], double, double, double> Map, ICompositeQuadRule <QuadRule> rule) { MPICollectiveWatchDog.Watch(csMPI.Raw._COMM.WORLD); using (new FuncTrace()) { LxNormQuadrature l2nq = new LxNormQuadrature(this, function, Map, rule); l2nq.Execute(); double nrmtot = l2nq.LxNorm.MPISum(); return(nrmtot); } }
/// <summary> /// Gets scalar functions from database connection /// </summary> /// <param name="connection">Instance of <see cref="DbConnection"/> class</param> /// <param name="scalarFunctions">Sequence of scalar functions</param> /// <returns>A sequence of <see cref="ScalarFunction"/> that represents existing views in database</returns> protected virtual IEnumerable<ScalarFunction> GetScalarFunctions(DbConnection connection, IEnumerable<DbObject> scalarFunctions) { foreach (var dbObject in scalarFunctions) { using (var command = connection.CreateCommand()) { var scalarFunction = new ScalarFunction { Schema = dbObject.Schema, Name = dbObject.Name }; command.Connection = connection; command.CommandText = string.Format("sp_help '{0}'", dbObject.FullName); var queryResults = new List<QueryResult>(); using (var dataReader = command.ExecuteReader()) { while (dataReader.NextResult()) { var queryResult = new QueryResult(); while (dataReader.Read()) { var names = SqlServerDatabaseFactoryHelper.GetNames(dataReader).ToList(); var row = new Dictionary<string, object>(); for (var i = 0; i < names.Count; i++) row.Add(names[i], dataReader.GetValue(i)); queryResult.Items.Add(row); } queryResults.Add(queryResult); } foreach (var result in queryResults) { foreach (var item in result.Items) { if (item.ContainsKey("Parameter_name")) AddParameter(scalarFunction, item); } } yield return scalarFunction; } } } }
public void CheckDevirative() { ScalarFunction x = "x"; ScalarFunction y = "y"; Assert.AreEqual(NewDevirative(0, x), 0); Assert.AreEqual(NewDevirative(y, x), 0); Assert.AreEqual(NewDevirative(x, x), 1); //Assert.AreEqual(NewDevirative(x * y, x).Calculate(), y); Assert.AreEqual(NewDevirative(op_Exponentiation(x, 2), x), 2 * x); Assert.AreEqual(NewDevirative(op_Exponentiation(x, 3), x), 3 * op_Exponentiation(x, 2)); Assert.AreEqual(NewDevirative(op_Exponentiation(x, y), x), y * op_Exponentiation(x, y - 1)); }
public void CheckConstants() { double a = Random.NextDouble(); double b = Random.NextDouble(); ScalarFunction x = "x"; ScalarFunction y = "y"; double? result = (x + y).Calculate(NewScalarFind("x", "x" == NewConstant(a)) & NewScalarFind("y", "y" == NewConstant(b))); Assert.AreEqual(a + b, result); result = (x - y).Calculate(NewScalarFind("x", "x" == NewConstant(a)) & NewScalarFind("y", "y" == NewConstant(b))); Assert.AreEqual(a - b, result); result = (x * y).Calculate(NewScalarFind("x", "x" == NewConstant(a)) & NewScalarFind("y", "y" == NewConstant(b))); Assert.AreEqual(a * b, result); }
/// <summary> /// Projects every basis polynomial for the quadrature rule of the /// given order onto a single cell grid supplied by the sub-class and /// approximates the LInfinity error of the projection. /// </summary> /// <remarks> /// The DG projection uses a quadrature rule of 2*n+1 for a basis of /// order n. Thus, make sure <paramref name="order"/> that a quadrature /// rule of order 2*order+1 exists before calling this method</remarks> /// <param name="order">The <b>requested</b> order</param> /// <param name="polynomials">The orthonormal polynomials</param> /// <param name="rule">The tested quadrature rule</param> private void TestProjectionError(int order, PolynomialList polynomials, QuadRule rule) { Basis basis = new Basis(context, order); for (int i = 0; i < polynomials.Count; i++) { if (2 * polynomials[i].AbsoluteDegree + 1 > order) { // Not integrable _exactly_ with this rule continue; } DGField field = new SinglePhaseField(basis); ScalarFunction function = delegate(MultidimensionalArray input, MultidimensionalArray output) { polynomials[i].Evaluate(output, new NodeSet(rule.RefElement, input)); }; field.ProjectField(function); double LInfError = 0; for (int j = 0; j < rule.NoOfNodes; j++) { MultidimensionalArray result = MultidimensionalArray.Create(1, 1); NodeSet point = new NodeSet(context.iGeomCells.GetRefElement(0), 1, rule.SpatialDim); for (int k = 0; k < rule.SpatialDim; k++) { point[0, k] = rule.Nodes[j, k]; } point.LockForever(); //Evaluate pointwise because we don't want the accumulated //result field.Evaluate(0, 1, point, result, 0.0); MultidimensionalArray exactResult = MultidimensionalArray.Create(1); polynomials[i].Evaluate(exactResult, point); LInfError = Math.Max(Math.Abs(result[0, 0] - exactResult[0]), LInfError); } //Console.WriteLine("ProjectionError: {0}", LInfError); Assert.IsTrue( LInfError <= 1e-13, String.Format( "Projection error too high for polynomial {0}. Error: {1:e}", i, LInfError)); } }
public void DefaultDbModelStore_saves_and_loads_DbContext_with_DbFunction_StoreModelConvention() { try { var dependencyResolver = new SingletonDependencyResolver <DbModelStore>(_store); MutableResolver.AddResolver <DbModelStore>(dependencyResolver); Assert.False(File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"), "edmx should not exist yet"); using (var context = new ScalarFunctionDbContext()) { context.Models.Add(new Model { Id = 1 }); context.SaveChanges(); Assert.True( context.Set <Model>().Any(model => ScalarFunction.GetSomething("inValue") == "inValue"), "Value passed in should be returned from db function without error"); } Assert.True( File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"), "edmx should be written to _location"); var xdocFromStore = _store.TryGetEdmx(typeof(ScalarFunctionDbContext)); Assert.NotNull(xdocFromStore); var compiledModelFromCache = _store.TryLoad(typeof(ScalarFunctionDbContext)); Assert.NotNull(compiledModelFromCache); using (var context = new ScalarFunctionDbContext(compiledModelFromCache)) { Assert.True( context.Set <Model>().Any(prd => ScalarFunction.GetSomething("inValue") == "inValue"), "Value passed in should be returned from db function without error"); } } finally //clean up { MutableResolver.ClearResolvers(); if (File.Exists(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx")) { File.Delete(_location + typeof(ScalarFunctionDbContext).FullName + ".edmx"); } } }
protected virtual IEnumerable <ScalarFunction> GetScalarFunctions(DbConnection connection, IEnumerable <DbObject> scalarFunctions) { foreach (var item in scalarFunctions) { using (var command = connection.CreateCommand()) { command.Connection = connection; command.CommandText = string.Format("sp_help '{0}'", item.FullName); using (var dataReader = command.ExecuteReader()) { while (dataReader.Read()) { var scalarFunction = new ScalarFunction { Schema = item.Schema, Name = item.Name }; dataReader.NextResult(); while (dataReader.Read()) { var procedureParameter = new Parameter { Name = string.Concat(dataReader["Parameter_name"]) }; procedureParameter.Type = string.Concat(dataReader["Type"]); procedureParameter.Length = short.Parse(string.Concat(dataReader["Length"])); procedureParameter.Prec = string.Concat(dataReader["Prec"]).Trim().Length == 0 ? default(int) : int.Parse(string.Concat(dataReader["Prec"])); procedureParameter.ParamOrder = string.Concat(dataReader["Param_order"]).Trim().Length == 0 ? default(int) : int.Parse(string.Concat(dataReader["Param_order"])); procedureParameter.Collation = string.Concat(dataReader["Collation"]); scalarFunction.Parameters.Add(procedureParameter); } yield return(scalarFunction); } } } } }
} // materializeTable() private List <SelectItem> buildWorkingSelectItems(List <SelectItem> selectItems, List <FilterItem> whereItems) { List <SelectItem> primarySelectItems = new List <SelectItem>(selectItems.Count); foreach (SelectItem selectItem in selectItems) { ScalarFunction scalarFunction = selectItem.getScalarFunction(); if (scalarFunction == null || isScalarFunctionMaterialized(scalarFunction)) { primarySelectItems.Add(selectItem); } else { SelectItem copySelectItem = selectItem.replaceFunction(null); primarySelectItems.Add(copySelectItem); } } List <SelectItem> evaluatedSelectItems = MetaModelHelper.getEvaluatedSelectItems(whereItems); return(CollectionUtils.concat(true, primarySelectItems, evaluatedSelectItems)); } // buildWorkingSelectItems()
public void FunctionEquals() { var func1 = new ScalarFunction("func"); func1.AddChild(new IntConstant(1)); func1.AddChild(new StringConstant("abc")); var func2 = new ScalarFunction("func"); func2.AddChild(new IntConstant(1)); func2.AddChild(new StringConstant("abc")); Assert.Equal(func1, func2); var func3 = new ScalarFunction("func"); func3.AddChild(new StringConstant("abc")); func3.AddChild(new IntConstant(1)); Assert.NotEqual(func1, func3); var func4 = (ScalarFunction)func2.Clone(); func4.SetChild(0, new StringConstant("123")); Assert.NotEqual(func2, func4); var func5 = new ScalarFunction("func"); Assert.NotEqual(func1, func5); var func6 = new ScalarFunction("func"); func6.AddChild(new IntConstant(1)); Assert.NotEqual(func1, func6); var func7 = new ScalarFunction("func"); func7.AddChild(new ColumnRef("tt", "col")); Assert.Single(func7.GetColumns()); Assert.Equal(new ColumnRef("tt", "col"), func7.GetColumns()[0]); }
/// <summary> /// Create reader friendly text for display of a functon return value /// </summary> /// <param name="param"></param> /// <returns></returns> public static string GetReturnTypeDisplayText(this ScalarFunction func) { var dispText = new StringBuilder(); if (!String.IsNullOrWhiteSpace(func.ReturnDataType)) { dispText.Append(func.ReturnDataType); } //has numeric precision and scale if (func.ReturnTypePrecision.HasValue && func.ReturnTypeScale.HasValue) { dispText.Append(String.Format("({0},{1})", func.ReturnTypePrecision.Value, func.ReturnTypeScale.Value)); } else { if (func.ReturnTypeMaximumLength.HasValue && func.ReturnTypeMaximumLength != -1) { dispText.Append(String.Format("({0})", func.ReturnTypeMaximumLength.Value)); } } return(dispText.ToString()); }
public override string AlterScalarFunction(DataContext sourceDataContext, DataContext targetDataContext, ScalarFunction scalarFunction) { return(sourceDataContext.ContextType != targetDataContext.ContextType ? null : MySqlModuleManager.GetAlterDefinition(scalarFunction.Definition)); }
/// <summary> /// Given a single-element input vector, scalar(v instant-vector) returns the sample value of that single element as a scalar. If the input vector does not have exactly one element, scalar will return NaN. /// </summary> /// <returns></returns> public InstantVector Scalar() { return(AddAction(ScalarFunction.Create())); }
public static string GetScalarFunctionMethodName(this EntityFrameworkCoreProject project, ScalarFunction scalarFunction) => string.Format("{0}{1}", project.CodeNamingConvention.GetClassName(scalarFunction.Schema), project.CodeNamingConvention.GetClassName(scalarFunction.Name));
} // buildWorkingSelectItems() /** * Determines if the subclass of this class can materialize * {@link SelectItem}s with the given {@link ScalarFunction}. Usually scalar * functions are applied by MetaModel on the client side, but when possible * they can also be handled by e.g. * {@link #materializeMainSchemaTable(Table, List, int, int)} and * {@link #materializeMainSchemaTable(Table, List, List, int, int)} in which * case MetaModel will not evaluate it client-side. * * @param function * @return */ protected bool isScalarFunctionMaterialized(ScalarFunction function) { return(false); } // isScalarFunctionMaterialized()
public int LoadScalarFunctions(bool FullLoad = false) { List<ScalarFunction> Functions = new List<ScalarFunction>(); string sql = @" SELECT ISNULL(sch.name, 'dbo') as 'Schema', sobj.id as FunctionId, sobj.name as FunctionName, cols.name as ParamName, type_name(cols.xusertype) as Type, isnull(cols.prec, 0) as Length, isnull(cols.Scale, 0) as Scale, isnull(cols.isnullable, 1) as Nullable, isnull(cols.iscomputed, 0) as Calculated FROM sysobjects sobj LEFT OUTER JOIN syscolumns cols ON sobj.id=cols.id LEFT JOIN Sys.Objects ObjAux ON sobj.id = ObjAux.object_id LEFT JOIN Sys.Schemas sch ON ObjAux.schema_id = sch.schema_id WHERE sobj.xtype = 'FN' ORDER BY sobj.id, cols.colid"; DataTable Info = new DataTable(); SqlCommand cmd = new SqlCommand(sql, Connection); try { SqlDataAdapter da = new SqlDataAdapter(); da.SelectCommand = cmd; da.SelectCommand.Connection.Open(); da.Fill(Info); da.SelectCommand.Connection.Close(); } catch (Exception) { cmd.Connection.Close(); return 0; } cmd.Dispose(); //DbObjects.RemoveAll(X => X.Kind == ObjectType.ScalarFunction); ScalarFunction CurObj = null; string curfunc = ""; int i, rowcount = Info.Rows.Count; for (i = 0; i < rowcount; i++) { if (!curfunc.Equals(Info.Rows[i]["FunctionName"].ToString(), StringComparison.CurrentCultureIgnoreCase)) {//agregar solo el campo CurObj = new ScalarFunction() { Name = Info.Rows[i]["FunctionName"].ToString(), Id = Convert.ToInt32(Info.Rows[i]["FunctionId"]), Schema = Info.Rows[i]["Schema"].ToString(), Comment = "" }; curfunc = CurObj.Name; Functions.Add(CurObj); } if (Info.Rows[i]["ParamName"] == DBNull.Value || String.IsNullOrEmpty(Info.Rows[i]["ParamName"].ToString())) continue; Parameter Param = new Parameter() { Comment = "", Computed = false, DefaultValue = "", ForeignKey = 0, Id = 0, IdentityScript = "", Increment = 0, IsForeignKey = false, IsIdentity = false, IsPrimaryKey = false, Name = Info.Rows[i]["ParamName"].ToString(), Nullable = true, Parent = CurObj, Precision = Convert.ToInt32(Info.Rows[i]["Length"]), ReferenceChild = null, ReferenceChildName = "", ReferenceParent = null, ReferenceParentName = "", Seed = 0, Type = Info.Rows[i]["Type"].ToString() }; CurObj.Childs.Add(Param); } if (FullLoad) { cmd.Connection.Open(); try { foreach (ISqlObject Funct in Functions) { Funct.LoadScript(cmd); } } catch (Exception) { ; } finally { cmd.Connection.Close(); } } DbObjects.AddRange(Functions); return Functions.Count; }
public XDGTestSetup( int p, double AggregationThreshold, int TrackerWidth, MultigridOperator.Mode mumo, XQuadFactoryHelper.MomentFittingVariants momentFittingVariant, ScalarFunction LevSetFunc = null) { // Level set, tracker and XDG basis // ================================ if (LevSetFunc == null) { LevSetFunc = ((_2D)((x, y) => 0.8 * 0.8 - x * x - y * y)).Vectorize(); } LevSet = new LevelSet(new Basis(grid, 2), "LevelSet"); LevSet.Clear(); LevSet.ProjectField(LevSetFunc); LsTrk = new LevelSetTracker(grid, XQuadFactoryHelper.MomentFittingVariants.Classic, TrackerWidth, new string[] { "A", "B" }, LevSet); LsTrk.UpdateTracker(); XB = new XDGBasis(LsTrk, p); XSpatialOperator Dummy = new XSpatialOperator(1, 0, 1, QuadOrderFunc.SumOfMaxDegrees(RoundUp: true), "C1", "u"); //Dummy.EquationComponents["c1"].Add(new Dummy.Commit(); //Tecplot.PlotFields(new DGField[] { LevSet }, "agglo", 0.0, 3); // operator // ======== Debug.Assert(p <= 4); XDGBasis opXB = new XDGBasis(LsTrk, 4); // we want to have a very precise quad rule var map = new UnsetteledCoordinateMapping(opXB); int quadOrder = Dummy.QuadOrderFunction(map.BasisS.Select(bs => bs.Degree).ToArray(), new int[0], map.BasisS.Select(bs => bs.Degree).ToArray()); //agg = new MultiphaseCellAgglomerator(new CutCellMetrics(momentFittingVariant, quadOrder, LsTrk, LsTrk.SpeciesIdS.ToArray()), AggregationThreshold, false); agg = LsTrk.GetAgglomerator(LsTrk.SpeciesIdS.ToArray(), quadOrder, __AgglomerationTreshold: AggregationThreshold); foreach (var S in LsTrk.SpeciesIdS) { Console.WriteLine("Species {0}, no. of agglomerated cells {1} ", LsTrk.GetSpeciesName(S), agg.GetAgglomerator(S).AggInfo.SourceCells.Count()); } // mass matrix factory // =================== // Basis maxB = map.BasisS.ElementAtMax(b => b.Degree); //MassFact = new MassMatrixFactory(maxB, agg); MassFact = LsTrk.GetXDGSpaceMetrics(LsTrk.SpeciesIdS.ToArray(), quadOrder, 1).MassMatrixFactory; // Test field // ========== // set the test field: this is a polynomial function, // but different for each species; On this field, restriction followed by prolongation should be the identity this.Xdg_uTest = new XDGField(this.XB, "uTest"); Dictionary <SpeciesId, double> dumia = new Dictionary <SpeciesId, double>(); int i = 2; foreach (var Spc in LsTrk.SpeciesIdS) { dumia.Add(Spc, i); i -= 1; } SetTestValue(Xdg_uTest, dumia); // dummy operator matrix which fits polynomial degree p // ==================================================== Xdg_opMtx = new BlockMsrMatrix(Xdg_uTest.Mapping, Xdg_uTest.Mapping); Xdg_opMtx.AccEyeSp(120.0); // XDG Aggregation BasiseS // ======================= //XAggB = MgSeq.Select(agGrd => new XdgAggregationBasis[] { new XdgAggregationBasis(uTest.Basis, agGrd) }).ToArray(); XAggB = new XdgAggregationBasis[MgSeq.Length][]; var _XAggB = AggregationGridBasis.CreateSequence(MgSeq, Xdg_uTest.Mapping.BasisS); for (int iLevel = 0; iLevel < XAggB.Length; iLevel++) { XAggB[iLevel] = new[] { (XdgAggregationBasis)(_XAggB[iLevel][0]) }; XAggB[iLevel][0].Update(agg); } // Multigrid Operator // ================== Xdg_opMtx = new BlockMsrMatrix(Xdg_uTest.Mapping, Xdg_uTest.Mapping); Xdg_opMtx.AccEyeSp(120.0); XdgMultigridOp = new MultigridOperator(XAggB, Xdg_uTest.Mapping, Xdg_opMtx, MassFact.GetMassMatrix(Xdg_uTest.Mapping, false), new MultigridOperator.ChangeOfBasisConfig[][] { new MultigridOperator.ChangeOfBasisConfig[] { new MultigridOperator.ChangeOfBasisConfig() { VarIndex = new int[] { 0 }, mode = mumo, Degree = p } } }); }
// @Override public WhereBuilder where (ScalarFunction function, Column column) { GroupedQueryBuilder query_builder = getQueryBuilder(); return((WhereBuilder)query_builder.where ((FilterItem)function, (FilterItem)column)); }
public static string CreateDescriptionSqlCommandText(this ScalarFunction func) { return(createAddExtendedPropertySprocTextForMsDescription(func.Description, "SCHEMA", func.Parent.ObjectName, "FUNCTION", func.FunctionName)); }
// @Override public WhereBuilder where (ScalarFunction function, String column_name) { GroupedQueryBuilder query_builder = getQueryBuilder(); return((WhereBuilder)query_builder.where (function, column_name)); }
public override string DropScalarFunction(DataContext sourceDataContext, DataContext targetDataContext, ScalarFunction scalarFunction) { if (sourceDataContext.ContextType != targetDataContext.ContextType) { return(null); } var builder = new StringBuilder(); builder.Append("DROP FUNCTION "); builder.Append(CreateIdentifier(scalarFunction)); return(builder.ToString()); }
/// <summary> /// Create a new ScalarFunction object. /// </summary> /// <param name="id">Initial value of Id.</param> /// <param name="name">Initial value of Name.</param> /// <param name="returnType">Initial value of ReturnType.</param> public static ScalarFunction CreateScalarFunction(string id, string name, TypeSpecification returnType) { ScalarFunction scalarFunction = new ScalarFunction(); scalarFunction.Id = id; scalarFunction.Name = name; scalarFunction.ReturnType = global::System.Data.Objects.DataClasses.StructuralObject.VerifyComplexObjectIsNotNull(returnType, "ReturnType"); return scalarFunction; }
public override string CreateScalarFunction(DataContext sourceDataContext, DataContext targetDataContext, ScalarFunction scalarFunction) { return(sourceDataContext.ContextType != targetDataContext.ContextType ? null : scalarFunction.Definition); }