public void ClearFunctionThatIsBoundToDecorator()
{
IFunction function = new Function("time series");
function.Arguments.Add(new Variable<DateTime>("time"));
function.Components.Add(new Variable<double>("water_discharge"));
// set initial values
DateTime time1 = DateTime.Now;
DateTime time2 = time1.AddMinutes(1);
DateTime time3 = time2.AddMinutes(1);
function[time1] = 0.0;
function[time2] = 1.0;
function[time3] = 2.0;
ILineChartSeries lineChartSeries = ChartSeriesFactory.CreateLineSeries();
lineChartSeries.XValuesDataMember = function.Arguments[0].DisplayName;
lineChartSeries.YValuesDataMember = function.Components[0].DisplayName;
var control = new Control();
WindowsFormsTestHelper.Show(control);
var functionBindingList = new FunctionBindingList(function) { SynchronizeInvoke = control };
lineChartSeries.DataSource = functionBindingList;
function.Clear();
while(functionBindingList.IsProcessing)
{
Application.DoEvents();
}
}
/// <summary>
/// Fills gridvalues function with profiledata based on profileline over the grid
/// </summary>
/// <param name="function"></param>
/// <param name="grid"></param>
/// <param name="polyline"></param>
public static void UpdateGridValues(Function function, IRegularGridCoverage grid, ILineString polyline)
{
function.Clear();
double offset = 0;
double step = polyline.Length / 100;
foreach (ICoordinate coordinate in GetGridProfileCoordinates(polyline, step))
{
function[offset] = grid.Evaluate(coordinate);
offset += step;
}
}
public void CheckFunctionValuesChangedConsistency()
{
//assert we only get a FunctionValuesChanged event when the function is consistent.
IFunction func = new Function();
IVariable x = new Variable<int>("x");
IVariable y = new Variable<int>("y");
func.Arguments.Add(x);
func.Components.Add(y);
func[0] = 2;
func.Store.FunctionValuesChanged += delegate
{
Assert.IsTrue(func.Components[0].Values.Count == func.Arguments[0].Values.Count);
};
func.Clear();
}
public void Clear()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IFunction f = new Function();
f.Arguments.Add(x);
f.Components.Add(y);
f.SetValues(new[] {100.0, 200.0, 300.0}, new VariableValueFilter<double>(x, new[] {1.0, 2.0, 3.0}));
IList values = f.GetValues();
Assert.AreEqual(3, values.Count);
f.Clear();
Assert.AreEqual(0, values.Count);
}
public void AddManyFunctionValuesWithBindingListShouldBeFast()
{
var f = new Function
{
Arguments = {new Variable<double>("x")},
Components = {new Variable<double>("y")}
};
var values = Enumerable.Range(0, 1000).Select(i => (double)i);
// first time is slower so we add/clear values a few times first
f.SetValues(values, new VariableValueFilter<double>(f.Arguments[0], values));
f.Clear();
f.SetValues(values, new VariableValueFilter<double>(f.Arguments[0], values));
f.Clear();
// measure overhead (add values to function)
var stopwatch = new Stopwatch();
stopwatch.Start();
AddValuesWithoutBindingList(f, values);
stopwatch.Stop();
var overhead = stopwatch.ElapsedMilliseconds;
log.DebugFormat("Added 1000 values to function in {0} ms", overhead);
f.Clear();
// add values with FunctionBindingList
new FunctionBindingList(f);
stopwatch.Reset();
stopwatch.Start();
AddValuesWithBindingList(f, values);
stopwatch.Stop();
log.DebugFormat("Added 1000 values to function wrapped with a binding list in {0} ms, {1}x slower", stopwatch.ElapsedMilliseconds, (stopwatch.ElapsedMilliseconds / (double)overhead));
(stopwatch.ElapsedMilliseconds - overhead)
.Should("Updating binding list should be fast").Be.LessThan(50);
(stopwatch.ElapsedMilliseconds / (double)overhead)
.Should("Setting values to function with function binding list should be almost as fast as without it")
.Be.LessThan(4);
}
public void ClearSourceFunctionShouldClearFilteredBindingList()
{
IFunction function = new Function
{
Arguments = { new Variable<int>("x")},
Components = { new Variable<int>("f") }
};
function[1] = 1;
function[2] = 4;
var filteredFunction = function.Filter(new VariableValueFilter<int>(function.Arguments[0], new[] { 1 }));
IFunctionBindingList functionBindingList = new FunctionBindingList { Function = filteredFunction };
functionBindingList.Count
.Should().Be.EqualTo(1);
function.Clear();
functionBindingList.Count
.Should().Be.EqualTo(0);
}
public void ClearSourceFunctionShouldClearBindingList()
{
IFunction function = new Function
{
Arguments = { new Variable<int>("x") },
Components = { new Variable<int>("f") }
};
function[1] = 1;
function[2] = 4;
var functionBindingList = new FunctionBindingList {Function = function};
functionBindingList.Count
.Should().Be.EqualTo(2);
function.Clear();
// wait until binding list is actually cleared.
WaitUntilLastOperationIsFinished(functionBindingList);
functionBindingList.Count
.Should().Be.EqualTo(0);
}
public void ClearFunction_ShouldNotClearAttributes()
{
// setup
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IFunction f = new Function();
f.Arguments.Add(x);
f.Components.Add(y);
string kie = "kie";
string expected = "veljoe";
f.Attributes[kie] = expected;
f.Components[0].Attributes[kie] = expected;
f.SetValues(new[] { 100.0, 200.0, 300.0 }, new VariableValueFilter<double>(x, new[] { 1.0, 2.0, 3.0 }));
// call
f.Clear();
// check
Assert.AreEqual(0, f.GetValues().Count);
var funcVal = f.Attributes[kie];
Assert.AreEqual(expected,funcVal);
var val = f.Components[0].Attributes[kie];
Assert.AreEqual(expected,val);
}
/// <summary>
/// Fills gridvalues function with profiledata based on profileline over the grid
/// </summary>
/// <param name="function"></param>
/// <param name="coverage"></param>
/// <param name="polyline"></param>
/// <param name="resolution">Defines the sample resolution along <paramref name="polyline"/> (each resolution step a sample).
/// Null will cause 101 samples to be take along the line uniformly.</param>
/// <exception cref="ArgumentException">When <paramref name="resolution"/> is 0.0 or less.</exception>
public static void UpdateProfileFunctionValues(Function function, ICoverage coverage, ILineString polyline, DateTime? time, double? resolution = null)
{
// when coverage is empty (has no times), we cannot call Evaluate below...
if (time != null && time.Equals(default(DateTime))) return;
function.Clear();
double offset = 0;
double step = resolution ?? polyline.Length / 100;
var gridProfileCoordinates = GetGridProfileCoordinates(polyline, step).ToArray();
foreach (ICoordinate coordinate in gridProfileCoordinates)
{
var value = time != null ? coverage.Evaluate(coordinate, time.Value) : coverage.Evaluate(coordinate);
if (value == null)
{
offset += step;
continue;
}
function[offset] = value;
offset += step;
}
}
