/// <summary>
/// Build the formula defined. This will create a func delegate matching with the parameters
/// and the return type specified.
/// </summary>
/// <returns>The func delegate for the defined formula.</returns>
public Delegate Build()
{
if (!resultDataType.HasValue)
{
throw new Exception("Please define a result data type for the formula.");
}
Func <IDictionary <string, double>, double> formula = engine.Build(formulaText, constants);
FuncAdapter adapter = new FuncAdapter();
return(adapter.Wrap(parameters, variables =>
{
if (!caseSensitive)
{
variables = EngineUtil.ConvertVariableNamesToLowerCase(variables);
}
engine.VerifyVariableNames(variables);
// Add the reserved variables to the dictionary
foreach (ConstantInfo constant in engine.ConstantRegistry)
{
variables.Add(constant.ConstantName, constant.Value);
}
return formula(variables);
}));
}
public Surface(
int Index,
ConfigurationData configurationData,
ISurfaceShape surfaceShape,
int initialConditionSurfaceIntegrationPointsCount_v,
int initialConditionSurfaceIntegrationPointsCount_w,
double initialTemperatureValue,
string heatSourceFunction,
int heatSourceSurfaceIntegrationPointsCount_v,
int heatSourceSurfaceIntegrationPointsCount_w,
bool subractSurface)
{
this.Index = Index;
var engine = new CalculationEngine();
this.SurfaceShape = surfaceShape;
this.InitialConditionSurfaceIntegrationPoints = this.calculateRegularSurfaceIntegrationPoints(initialConditionSurfaceIntegrationPointsCount_v, initialConditionSurfaceIntegrationPointsCount_w, initialTemperatureValue, configurationData);
this.subractSurface = subractSurface;
this.initialTemperatureValue = initialTemperatureValue;
if (configurationData.addHeatSource)
{
this.heatSourceFunction = engine.Build(heatSourceFunction);
this.HeatSourceSurfaceIntegrationPoints = this.calculateRegularSurfaceIntegrationPoints(heatSourceSurfaceIntegrationPointsCount_v, heatSourceSurfaceIntegrationPointsCount_w, 0, configurationData);
}
}
public TimeIntervalBoundaryCondition(double startTime, double endTime, string function)
{
this.StartTime = startTime;
this.EndTime = endTime;
var engine = new CalculationEngine();
this.Function = engine.Build(function);
}
public MaterialProperties(string DiffusionCoefficient, bool timeDependentDiffusionCoefficient, string ThermalConductivity, bool timeDependentThermalConductivity)
{
var engine = new CalculationEngine();
this.DiffusionCoefficientEquation = engine.Build(DiffusionCoefficient);
this.ThermalConductivityEquation = engine.Build(ThermalConductivity);;
this.timeDependentDiffusionCoefficient = timeDependentDiffusionCoefficient;
this.timeDependentThermalConductivity = timeDependentThermalConductivity;
if (!timeDependentDiffusionCoefficient)
{
this.DiffusionCoefficientConstantValue = double.Parse(DiffusionCoefficient);
}
if (!timeDependentThermalConductivity)
{
this.ThermalConductivityConstantValue = double.Parse(ThermalConductivity);
}
}
public ConfigurationData(string DiffusionCoefficient, bool timeDependentDiffusionCoefficient, string ThermalConductivity, bool timeDependentThermalConductivity, IterationProcess iterationProcess)
{
var engine = new CalculationEngine();
this.DiffusionCoefficientEquation = engine.Build(DiffusionCoefficient);
this.ThermalConductivityEquation = engine.Build(ThermalConductivity);;
this.timeDependentDiffusionCoefficient = timeDependentDiffusionCoefficient;
this.timeDependentThermalConductivity = timeDependentThermalConductivity;
if (!timeDependentDiffusionCoefficient)
{
this.DiffusionCoefficientConstantValue = double.Parse(DiffusionCoefficient);
}
if (!timeDependentThermalConductivity)
{
this.ThermalConductivityConstantValue = double.Parse(ThermalConductivity);
}
this.iterationProcess = iterationProcess;
}
private void ParseCode()
{
if (string.IsNullOrEmpty(_code))
{
throw new Exception("heyy");
}
_variables.Clear();
_variables.Add("t", 0);
_formula = _engine.Build(_code);
//todo?
}
public void TestCalculationFormulaBuildingWithConstantsCache6()
{
CalculationEngine engine = new CalculationEngine(CultureInfo.InvariantCulture, ExecutionMode.Interpreted);
var fn = engine.Build("a+b+c", new Dictionary <string, double> {
{ "a", 1 }
});
double result = fn(new Dictionary <string, double> {
{ "b", 2 }, { "c", 2 }
});
Assert.AreEqual(5.0, result);
var fn1 = engine.Build("a+b+c", new Dictionary <string, double> {
{ "a", 2 }
});
double result1 = fn1(new Dictionary <string, double> {
{ "b", 2 }, { "c", 2 }
});
Assert.AreEqual(6.0, result1);
}
public void TestVariableCaseFuncCompiled()
{
CalculationEngine engine = new CalculationEngine(CultureInfo.InvariantCulture, ExecutionMode.Compiled);
Func <Dictionary <string, double>, double> formula = engine.Build("var1+2/(3*otherVariablE)");
Dictionary <string, double> variables = new Dictionary <string, double>();
variables.Add("var1", 2);
variables.Add("otherVariable", 4.2);
double result = formula(variables);
}
public void TestBuild()
{
CalculationEngine engine = new CalculationEngine();
Func<Dictionary<string, double>, double> function = engine.Build("var1+2*(3*age)");
Dictionary<string, double> variables = new Dictionary<string, double>();
variables.Add("var1", 2);
variables.Add("age", 4);
double result = function(variables);
Assert.AreEqual(26.0, result);
}
public Delegate Build()
{
if (!resultDataType.HasValue)
{
throw new Exception("Please define a result data type for the formula.");
}
Func <Dictionary <string, double>, double> formula = engine.Build(formulaText);
FuncAdapter adapter = new FuncAdapter();
return(adapter.Wrap(parameters, variables => formula(variables)));
}
public void TestCalculationFormulaBuildingWithConstantsCache2()
{
CalculationEngine engine = new CalculationEngine(new JaceOptions {
CacheEnabled = true
});
var fn = engine.Build("a+b+c");
double result = fn(new Dictionary <string, double> {
{ "a", 1 }, { "b", 2 }, { "c", 2 }
});
Assert.AreEqual(5.0, result);
var fn1 = engine.Build("a+b+c", new Dictionary <string, double> {
{ "a", 2 }
});
double result1 = fn1(new Dictionary <string, double> {
{ "b", 2 }, { "c", 2 }
});
Assert.AreEqual(6.0, result1);
}
public void TestBuild()
{
CalculationEngine engine = new CalculationEngine();
Func <Dictionary <string, double>, double> function = engine.Build("var1+2*(3*age)");
Dictionary <string, double> variables = new Dictionary <string, double>();
variables.Add("var1", 2);
variables.Add("age", 4);
double result = function(variables);
Assert.AreEqual(26.0, result);
}
public void TestCalculationFormulaBuildingWithConstantsCache1()
{
CalculationEngine engine = new CalculationEngine(new JaceOptions {
CacheEnabled = true
});
var fn = engine.Build("a+b+c", new Dictionary <string, double> {
{ "a", 1 }
});
double result = fn(new Dictionary <string, double> {
{ "b", 2 }, { "c", 2 }
});
Assert.AreEqual(5.0, result);
AssertExtensions.ThrowsException <VariableNotDefinedException>(() =>
{
var fn1 = engine.Build("a+b+c");
double result1 = fn1(new Dictionary <string, double> {
{ "b", 3 }, { "c", 3 }
});
});
}
public BoundaryCondition(BoundaryConditionType BoundaryConditionType, int degree, string expression, BoundaryConditionValueType boundaryConditionValueType, TimeIntervalBoundaryConditionHelper timeIntervalValueBoundaryConditionHelper, RobinBoundaryConditionHelper robinBoundaryConditionHelper)
{
this.BoundaryConditionType = BoundaryConditionType;
this.degree = degree;
this.boundaryConditionValueType = boundaryConditionValueType;
this.robinBoundaryConditionHelper = robinBoundaryConditionHelper;
this.timeIntervalValueBoundaryConditionHelper = timeIntervalValueBoundaryConditionHelper;
if (expression != string.Empty)
{
var engine = new CalculationEngine();
this.BoundaryValueExpression = engine.Build(expression);
}
CreateBoundaryConditionVector(degree, new double[] { });
}
public void TestVariableCaseFuncInterpreted()
{
CalculationEngine engine = new CalculationEngine(CultureInfo.InvariantCulture, ExecutionMode.Interpreted);
Func<Dictionary<string, double>, double> formula = engine.Build("var1+2/(3*otherVariablE)");
Dictionary<string, double> variables = new Dictionary<string, double>();
variables.Add("var1", 2);
variables.Add("otherVariable", 4.2);
double result = formula(variables);
}
private void ExecuteCalculate()
{
CalculationEngine engine = new CalculationEngine();
var formula = engine.Build(this.Formula);
this.Result = formula(this.Variables.ToDictionary(k => k.Name, v => v.Value));
}
private TFunc Build <TFunc>() where TFunc : Delegate => engine.Build <TFunc>(formulaText, parameters);
