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);
}
