[Ignore("Unfinished, 15.06.2009")] // TODO: unfinished test
public void IndependendFunctionTwoComponents()
{
//every pair of c1 c2 is a value of the independed function
IVariable x = new Variable <Pair <int, double> >();
//independend function
Assert.IsTrue(x.IsIndependent);
Assert.AreEqual(2, x.Components.Count, "tuple variable is composite variables containing variable for each tuple component");
Assert.AreEqual(typeof(int), x.Components[0]);
Assert.AreEqual(typeof(double), x.Components[0]);
x.SetValues(new[] { new Pair <int, double>(2, 1.0) });
IVariable <int> y = new Variable <int>();
y.Arguments.Add(x);
Assert.AreEqual(1, y.Values.Count);
x.SetValues(new[] { new Pair <int, double>(3, 1.0) });
Assert.AreEqual(2, y.Values.Count);
}
public void PerformanceAddValuesToArgument_UsingSetValues_WithEvents()
{
var x = new Variable <DateTime>("x");
var y = new Variable <double>("y")
{
Arguments = { x }
};
// prepare values
var xValues = new List <DateTime>();
var yValues = new List <double>();
const int ValuesToAdd = 50000;
var t = DateTime.Now;
var time = DateTime.Now;
for (var i = 0; i < ValuesToAdd; i++)
{
xValues.Add(time);
yValues.Add(i);
time = time.AddDays(1);
}
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Added {0} values in {1} ms", ValuesToAdd, dt);
TestHelper.AssertIsFasterThan(220, string.Format("Add {0} vlaues to function", ValuesToAdd), () =>
{
x.SetValues(xValues);
y.SetValues(yValues);
});
}
public void GetIndependentValuesUsingMultipleFilters()
{
Variable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
IFunctionStore store = x.Store;
IMultiDimensionalArray <int> filteredValues;
filteredValues = store.GetVariableValues <int>(
x,
new VariableValueFilter <int>(x, new[] { 1, 2, 3 })
);
Assert.AreEqual(3, filteredValues.Count);
Assert.AreEqual(1, filteredValues[0]);
//same filters different ordering
filteredValues = store.GetVariableValues <int>(
x,
new VariableValueFilter <int>(x, new[] { 3, 2, 1 })
);
Assert.AreEqual(3, filteredValues.Count);
Assert.AreEqual(1, filteredValues[0]);
}
public void ChangeYMemberSeriesViewWithFunctionAsDataSource()
{
var function = new Function();
var Y = new Variable <double>("Y");
var Z = new Variable <double>("Z");
var n = new Variable <double>("n");
function.Arguments.Add(Y);
function.Components.Add(Z);
function.Components.Add(n);
Y.SetValues(new[] { 0.0, 3.0, 5.0, 6.0, 7.0 });
Z.SetValues(new[] { 0.0, 10.0, 15.0, 21.0, 15.0 });
n.SetValues(new[] { 0.001, 0.001, 0.01, 0.01, 0.01 });
var chartView = new ChartView();
IChartSeries series = ChartSeriesFactory.CreateLineSeries();
series.XValuesDataMember = Y.DisplayName;
series.YValuesDataMember = Z.DisplayName;
series.DataSource = new FunctionBindingList(function)
{
SynchronizeInvoke = chartView
};
chartView.Chart.Series.Add(series);
WindowsFormsTestHelper.ShowModal(chartView);
}
public void SetValuesUsingFilters2D()
{
//Y is dependend of x1 and x2.
IVariable <int> y = new Variable <int>();
IVariable <int> x1 = new Variable <int>();
IVariable <int> x2 = new Variable <int>();
y.Arguments.Add(x1);
y.Arguments.Add(x2);
x1.SetValues(new[] { 0, 1, 2 });
x2.SetValues(new[] { 0, 1, 2 });
Assert.AreEqual(9, y.Values.Count);
//set y = 2 where x = 0 or x=2
//or is this call wrong and should it be {5,5} or setfunctionValue
y.Store.SetVariableValues(y, new[] { 5 }, new VariableValueFilter <int>(x1, new[] { 0 }));
//check values of y using MDA interface. The first argument is x1
Assert.AreEqual(5, y.Values[0, 0]);
Assert.AreEqual(5, y.Values[0, 1]);
Assert.AreEqual(5, y.Values[0, 2]);
y.Store.SetVariableValues(y, new[] { 3, 2, 1 }, new VariableValueFilter <int>(x2, new[] { 0 }));
Assert.AreEqual(3, y.Values[0, 0]);
Assert.AreEqual(2, y.Values[1, 0]);
Assert.AreEqual(1, y.Values[2, 0]);
Assert.AreEqual(5, y.Values[0, 1]);
Assert.AreEqual(5, y.Values[0, 2]);
}
public void GetUniformInterpolatedValue()
{
IVariable <double> x = new Variable <double>("x");
IVariable <double> y = new Variable <double>("y");
IVariable <double> f1 = new Variable <double>("f1");
f1.Arguments.Add(x);
f1.Arguments.Add(y);
var xValues = new[] { 1.0, 2.0 };
var yValues = new[] { 1.0, 2.0 };
var fValues = new[, ]
{
{ 100.0, 100.0 },
{ 100.0, 100.0 }
};
f1.SetValues(fValues,
new VariableValueFilter <double>(x, xValues),
new VariableValueFilter <double>(y, yValues));
var value = f1.Evaluate <double>(
new VariableValueFilter <double>(x, 1.5),
new VariableValueFilter <double>(y, 1.5));
Assert.AreEqual(100, value);
}
public void SetValuesWithAWrongTypeGivesFormatException()
{
IVariable <int> x = new Variable <int>();
//go and put a bad string in there
x.SetValues(new [] { "lalala" });
}
public void FilterFilteredFunction()
{
IVariable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
var filtered = x.Filter(x.CreateValuesFilter(new[] { 2, 3, 4 }));
var filtered2 = filtered.Filter(x.CreateValueFilter(3));
Assert.AreEqual(3, filtered.Values.Count);
Assert.IsTrue(filtered.Values.Cast <int>().SequenceEqual(new[] { 2, 3, 4 }));
Assert.AreEqual(1, filtered2.Values.Count);
Assert.AreEqual(3, filtered2.Values[0]);
// change filters
((IVariableValueFilter)filtered2.Filters[0]).Values.Add(5);
((IVariableValueFilter)filtered2.Filters[0]).Values.Add(4);
Assert.AreEqual(2, filtered2.Values.Count);
// expanding filter in the "filtered" will also expand "filtered2"
((IVariableValueFilter)filtered.Filters[0]).Values.Add(5);
Assert.AreEqual(4, filtered.Values.Count);
Assert.AreEqual(3, filtered2.Values.Count);
}
public void FilterDependend()
{
IVariable <int> y = new Variable <int>("y");
IVariable <int> x = new Variable <int>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
//update y where x = 2
Assert.IsFalse(y.Values.IsAutoSorted);
y[2] = 10;
Assert.AreEqual(new[] { 0, 10, 0, 0, 0, 0, 0, 0, 0, 0 }, y.Values);
//update y where x = 8
y[8] = 10;
Assert.AreEqual(new[] { 0, 10, 0, 0, 0, 0, 0, 10, 0, 0 }, y.Values);
//select two ranges ..from [1..3] and [7..9]
IList <Pair <int, int> > indexRanges = new List <Pair <int, int> >();
indexRanges.Add(new Pair <int, int>(0, 2));
indexRanges.Add(new Pair <int, int>(6, 8));
IVariable <int> filteredY = (IVariable <int>)y.Filter(new VariableIndexRangesFilter(x, indexRanges));
Assert.AreEqual(6, filteredY.Values.Count);
Assert.IsTrue(new[] { 0, 10, 0, 0, 10, 0 }.SequenceEqual(filteredY.Values));
}
public void CreateFunction()
{
var index1Variable = new Variable <int>("index1")
{
Values = { 0, 1, 2 }
};
var index2Variable = new Variable <int>("index2")
{
Values = { 0, 1 }
};
var xVariable = new Variable <double>("x")
{
Arguments = { index1Variable, index2Variable }
};
var yVariable = new Variable <double>("y")
{
Arguments = { index1Variable, index2Variable }
};
var valuesVariable = new Variable <double>("value")
{
Arguments = { index1Variable, index2Variable }
};
xVariable.SetValues(new[, ]
{
{ 1.0, 2.0, 3.0 },
{ 4.0, 5.0, 6.0 }
});
yVariable.SetValues(new[, ]
{
{ 1.0, 2.0, 3.0 },
{ 4.0, 5.0, 6.0 }
});
valuesVariable.SetValues(new[, ]
{
{ 1.0, 2.0, 3.0 },
{ 4.0, 5.0, 6.0 }
});
var variables = new IVariable[] { index1Variable, index2Variable, xVariable, yVariable, valuesVariable };
var builder = new DiscreteGridPointCoverageBuilder
{
Index1VariableName = "index1",
Index2VariableName = "index2",
XVariableName = "x",
YVariableName = "y",
ValuesVariableName = "value"
};
var coverage = (IDiscreteGridPointCoverage)builder.CreateFunction((variables));
Assert.AreEqual(3, coverage.Index1.Values.Count);
Assert.AreEqual(2, coverage.Index2.Values.Count);
Assert.AreEqual(6, coverage.X.Values.Count);
Assert.AreEqual(6, coverage.Y.Values.Count);
Assert.AreEqual(5.0, coverage.Evaluate <double>(5.0, 5.0));
}
[Test] //this used to lead to an invalid operation exception, but it should not
public void ReplaceDateTimeValue()
{
var dateTime = new DateTime(2008, 1, 1);
IVariable v = new Variable <DateTime>();
v.SetValues(new DateTime[] { new DateTime(2008, 1, 1) });
v.Values[0] = dateTime;
}
public void MakeFilteringLessTypeSensitive()
{
IVariable <double> x = new Variable <double>();
x.SetValues(new[] { 1.0, 2.0, 3.0 });
IMultiDimensionalArray <double> xValues = x.Store.GetVariableValues <double>(x, new VariableValueFilter <double>(x, 2));
Assert.AreEqual(2.0, xValues[0]);
}
public void AddNonUniqueDateTimeValue()
{
var dateTime = new DateTime(2008, 1, 1);
IVariable v = new Variable <DateTime>();
v.SetValues(new DateTime[] { new DateTime(2008, 1, 1) });
//try adding non-unique value (not allowed)
v.Values.Add(dateTime);
}
public void AddFilter()
{
IVariable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
x.Filters.Add(x.CreateValuesFilter(new[] { 2, 3, 4 }));
Assert.IsTrue(x.Values.SequenceEqual(new[] { 2, 3, 4 }));
}
public void SetAndGetValuesAsArrayNonGeneric()
{
IVariable v = new Variable <double>();
v.SetValues(new[] { 0.0, 0.1, 0.2 });
IList values = v.Values;
Assert.AreEqual(3, v.Values.Count);
Assert.AreEqual(0.1, values[1]);
}
public void VariableWithoutSort()
{
var x = new Variable <int> {
IsAutoSorted = false
};
var values = new[] { 2, 1, 3 };
x.SetValues(values);
Assert.AreEqual(values, x.Values, "no sorting must take place");
}
public void VariableValueRanges()
{
IVariable<int> x = new Variable<int>();
x.SetValues(new[]{1,2,3,4,5,6,7,8,9,10});
//select two ranges ..from [1..3] and [7.8]
IList<Pair<int,int>> ranges = new List<Pair<int, int>>();
ranges.Add(new Pair<int, int>(1,3));
ranges.Add(new Pair<int, int>(7,8));
x = (IVariable<int>)x.Filter(new VariableValueRangesFilter<int>(x,ranges));
Assert.AreEqual(5, x.Values.Count);
Assert.AreEqual(new[] { 1, 2, 3, 7, 8}, x.Values.ToArray());
}
public void FilterIndependend()
{
IVariable<int> x = new Variable<int>();
x.SetValues(new[]{1,2,3,4,5,6,7,8,9,10});
//select two ranges ..from [1..3] and [7..9]
IList<Pair<int, int>> indexRanges= new List<Pair<int, int>>();
indexRanges.Add(new Pair<int, int>(0,2));
indexRanges.Add(new Pair<int, int>(6,8));
IVariable<int> filteredX = (IVariable<int>) x.Filter(new VariableIndexRangesFilter(x, indexRanges));
Assert.AreEqual(6, filteredX.Values.Count);
Assert.IsTrue(new[]{1,2,3,7,8,9}.SequenceEqual(filteredX.Values));
}
public void FilterIndependendVariable()
{
IVariable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
//filter out the middle
var filtered = x.Filter(x.CreateValuesFilter(new[] { 2, 3, 4 }));
Assert.AreEqual(3, filtered.Values[1]);
Assert.AreEqual(3, filtered.GetValues().Count);
}
public void VariableValueRanges()
{
IVariable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
//select two ranges ..from [1..3] and [7.8]
IList <Pair <int, int> > ranges = new List <Pair <int, int> >();
ranges.Add(new Pair <int, int>(1, 3));
ranges.Add(new Pair <int, int>(7, 8));
x = (IVariable <int>)x.Filter(new VariableValueRangesFilter <int>(x, ranges));
Assert.AreEqual(5, x.Values.Count);
Assert.AreEqual(new[] { 1, 2, 3, 7, 8 }, x.Values.ToArray());
}
public void EmptyFilter()
{
IVariable<double> y = new Variable<double>("y");
IVariable<double> x = new Variable<double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter();
Assert.AreEqual(3, filtered.Arguments[0].Values.Count);
}
public void EmptyFilter()
{
IVariable <double> y = new Variable <double>("y");
IVariable <double> x = new Variable <double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter();
Assert.AreEqual(3, filtered.Arguments[0].Values.Count);
}
public void IsSortedWorks()
{
IVariable <int> unsorted = new Variable <int>();
unsorted.AutoSort = false;
unsorted.SetValues(new[] { 2, 1, 3 });
Assert.AreEqual(new[] { 2, 1, 3 }, unsorted.Values);
IVariable <int> sorted = new Variable <int>();
sorted.SetValues(new[] { 2, 1, 3 });
//auto sort!
Assert.AreEqual(new[] { 1, 2, 3 }, sorted.Values);
}
public void FilterIndependend()
{
IVariable <int> x = new Variable <int>();
x.SetValues(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
//select two ranges ..from [1..3] and [7..9]
IList <Pair <int, int> > indexRanges = new List <Pair <int, int> >();
indexRanges.Add(new Pair <int, int>(0, 2));
indexRanges.Add(new Pair <int, int>(6, 8));
IVariable <int> filteredX = (IVariable <int>)x.Filter(new VariableIndexRangesFilter(x, indexRanges));
Assert.AreEqual(6, filteredX.Values.Count);
Assert.IsTrue(new[] { 1, 2, 3, 7, 8, 9 }.SequenceEqual(filteredX.Values));
}
public void GetValueOfFilteredFunctionUsingValueOfFiltererArgument()
{
IVariable <double> y = new Variable <double>("y");
IVariable <double> x = new Variable <double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter(x.CreateValueFilter(2.0));
//arguments of filtered functions are ignored!
Assert.IsNull(filtered[3.0]);
}
public void FilterDependendVariable()
{
//int sa = componentArrays.Aggregate(1, (product, item) => (product *= item.Count));
IVariable <double> y = new Variable <double>("y");
IVariable <double> x = new Variable <double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter(x.CreateValueFilter(2.0));
Assert.AreEqual(1, filtered.Components[0].Values.Count);
Assert.AreEqual(20, filtered.Values[0]);
}
public void FilterDependendVariable()
{
//int sa = componentArrays.Aggregate(1, (product, item) => (product *= item.Count));
IVariable<double> y = new Variable<double>("y");
IVariable<double> x = new Variable<double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter(x.CreateValueFilter(2.0));
Assert.AreEqual(1, filtered.Components[0].Values.Count);
Assert.AreEqual(20, filtered.Values[0]);
}
public void StoreTwoIndependentVariables()
{
IVariable x = new Variable <double>();
IVariable y = new Variable <double>();
x.Store.Functions.Add(y); // use store from x
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0, 40.0 });
var store = x.Store;
Assert.AreEqual(2, store.Functions.Count);
Assert.AreEqual(3, store.GetVariableValues(x).Count);
Assert.AreEqual(4, store.GetVariableValues(y).Count);
}
public void DependentVariableValues()
{
IVariable <double> x = new Variable <double>("x");
IVariable <double> y = new Variable <double>("y");
y.Arguments.Add(x); // make y = y(x)
x.SetValues(new[] { 0.0, 0.1, 0.2 });
Assert.AreEqual(3, x.Values.Count);
Assert.AreEqual(3, y.Values.Count);
Assert.AreEqual(y.DefaultValue, y.Values[0]);
y[0.0] = 5.0d;
Assert.AreEqual(5.0, y[0.0]);
}
public void GetIndependentValuesFiltersGeneric()
{
IFunctionStore store = new MemoryFunctionStore();
IVariable <double> x1 = new Variable <double>("x1");
//add one independent variable
store.Functions.Add(x1);
x1.SetValues(new[] { 0.0d, 1.0d, 2.0d });
Assert.AreEqual(0.0, x1.Values[0]);
IMultiDimensionalArray <double> filteredValues = store.GetVariableValues <double>(x1, new VariableValueFilter <double>(x1, new[] { 0.0d, 2.0d }));
Assert.AreEqual(0.0, filteredValues[0]);
Assert.AreEqual(2.0, filteredValues[1]);
}
public void ReduceFitlterShouldPassIsEditableProperty()
{
IVariable<int> x = new Variable<int>("x"){IsEditable = false};
IVariable<int> y = new Variable<int>("y");
IVariable<int> fx = new Variable<int>("fx");
fx.Arguments.Add(x);
fx.Arguments.Add(y);
x.SetValues(new[] { 1, 2, 3 });
y.SetValues(new[] { 1 });
fx[3, 1] = 20;
var reducedFunction = fx.Filter(new VariableReduceFilter(y));
Assert.AreEqual(1, reducedFunction.Arguments.Count);
Assert.AreEqual("x", reducedFunction.Arguments[0].Name);
Assert.IsFalse(reducedFunction.Arguments[0].IsEditable);
}
public void FilterDependend()
{
IVariable<int> y = new Variable<int>();
IVariable<int> x = new Variable<int>();
y.Arguments.Add(x);
x.SetValues(new[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
y[2] = 10;
y[8] = 10;
//select two ranges ..from [1..3] and [7..9]
IList<Pair<int, int>> indexRanges = new List<Pair<int, int>>();
indexRanges.Add(new Pair<int, int>(0, 2));
indexRanges.Add(new Pair<int, int>(6, 8));
IVariable<int> filteredY = (IVariable<int>) y.Filter(new VariableIndexRangesFilter(x, indexRanges));
Assert.AreEqual(6, filteredY.Values.Count);
Assert.IsTrue(new[] {0, 10, 0, 0, 10, 0}.SequenceEqual(filteredY.Values));
}
public void SimpleReduce()
{
IVariable<int> x = new Variable<int>("x");
IVariable<int> y = new Variable<int>("y");
IVariable<int> fx = new Variable<int>("fx");
fx.Arguments.Add(x);
fx.Arguments.Add(y);
x.SetValues(new[] {1, 2, 3});
y.SetValues(new[] {1});
fx[3, 1] = 20;
var reducedFunction = fx.Filter(new VariableValueFilter<int>(y, 1), new VariableReduceFilter(y));
Assert.AreEqual(1, reducedFunction.Arguments.Count);
Assert.AreEqual(3, reducedFunction.Values.Count);
Assert.AreEqual(20, reducedFunction.Values[2]);
}
public void CreateFunction()
{
var index1Variable = new Variable<int>("index1") { Values = {0, 1, 2} };
var index2Variable = new Variable<int>("index2") { Values = {0, 1} };
var xVariable = new Variable<double>("x") { Arguments = { index1Variable, index2Variable } };
var yVariable = new Variable<double>("y") { Arguments = { index1Variable, index2Variable } };
var valuesVariable = new Variable<double>("value") { Arguments = { index1Variable, index2Variable } };
xVariable.SetValues(new[,]
{
{1.0, 2.0, 3.0},
{4.0, 5.0, 6.0}
});
yVariable.SetValues(new[,]
{
{1.0, 2.0, 3.0},
{4.0, 5.0, 6.0}
});
valuesVariable.SetValues(new[,]
{
{1.0, 2.0, 3.0},
{4.0, 5.0, 6.0}
});
var variables = new IVariable[] { index1Variable, index2Variable, xVariable, yVariable, valuesVariable };
var builder = new DiscreteGridPointCoverageBuilder
{
Index1VariableName = "index1",
Index2VariableName = "index2",
XVariableName = "x",
YVariableName = "y",
ValuesVariableName = "value"
};
var coverage = (IDiscreteGridPointCoverage)builder.CreateFunction((variables));
Assert.AreEqual(3, coverage.Index1.Values.Count);
Assert.AreEqual(2, coverage.Index2.Values.Count);
Assert.AreEqual(6, coverage.X.Values.Count);
Assert.AreEqual(6, coverage.Y.Values.Count);
Assert.AreEqual(5.0, coverage.Evaluate<double>(5.0, 5.0));
}
public void FilterFunction()
{
IVariable <double> x = new Variable <double>("x");
IVariable <double> y = new Variable <double>("y");
IVariable <double> fx = new Variable <double>("fx");
IVariable <double> fy = new Variable <double>("fy");
IFunction f = new Function();
f.Arguments.Add(x);
f.Arguments.Add(y);
f.Components.Add(fx);
f.Components.Add(fy);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0 });
f.Components[0].Values[1, 1] = 100.0;
f.Components[1].Values[1, 1] = 200.0;
// fx 10.0 20.0
// ------------
// 1.0 | 0.0 0.0
// 2.0 | 0.0 100.0
// 3.0 | 0.0 0.0
//
// fy 10.0 20.0
// ------------
// 1.0 | 0.0 0.0
// 2.0 | 0.0 200.0
// 3.0 | 0.0 0.0
var filteredFunction = f.Filter(x.CreateValueFilter(2.0), y.CreateValueFilter(20.0));
Assert.AreEqual(2, filteredFunction.Components.Count);
Assert.AreEqual(2, filteredFunction.Arguments.Count);
Assert.AreEqual(1, filteredFunction.Arguments[0].Values.Count);
Assert.AreEqual(1, filteredFunction.Arguments[1].Values.Count);
Assert.AreEqual(1, filteredFunction.Components[0].Values.Count);
Assert.AreEqual(1, filteredFunction.Components[1].Values.Count);
Assert.AreEqual(100.0, filteredFunction.Components[0].Values[0]);
Assert.AreEqual(200.0, filteredFunction.Components[1].Values[0]);
}
public void PerformanceAddValuesToArgument_UsingSetValues_WithEvents()
{
IVariable <DateTime> x = new Variable <DateTime>("x");
IVariable <double> y = new Variable <double>("y");
y.Arguments.Add(x); // make y = y(x)
const int valuesToAdd = 50000;
var t = DateTime.Now;
var xValues = new List <DateTime>();
var yValues = new List <double>();
var time = DateTime.Now;
for (var i = 0; i < valuesToAdd; i++)
{
xValues.Add(time);
yValues.Add(i);
time = time.AddDays(1);
}
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
Assert.Less(dt, 20);
t = DateTime.Now;
// TODO: split the test in 2
// now set everything in 1 step (TODO: IMPROVE PERFORMANCE HERE)
x.SetValues(xValues);
y.SetValues(yValues);
dt = DateTime.Now.Subtract(t).TotalMilliseconds;
Assert.Less(dt, 690);
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
}
public void FilterFunction()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IVariable<double> fx = new Variable<double>("fx");
IVariable<double> fy = new Variable<double>("fy");
IFunction f = new Function();
f.Arguments.Add(x);
f.Arguments.Add(y);
f.Components.Add(fx);
f.Components.Add(fy);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0 });
f.Components[0].Values[1, 1] = 100.0;
f.Components[1].Values[1, 1] = 200.0;
// fx 10.0 20.0
// ------------
// 1.0 | 0.0 0.0
// 2.0 | 0.0 100.0
// 3.0 | 0.0 0.0
//
// fy 10.0 20.0
// ------------
// 1.0 | 0.0 0.0
// 2.0 | 0.0 200.0
// 3.0 | 0.0 0.0
var filteredFunction = f.Filter(x.CreateValueFilter(2.0), y.CreateValueFilter(20.0));
Assert.AreEqual(2, filteredFunction.Components.Count);
Assert.AreEqual(2, filteredFunction.Arguments.Count);
Assert.AreEqual(1, filteredFunction.Arguments[0].Values.Count);
Assert.AreEqual(1, filteredFunction.Arguments[1].Values.Count);
Assert.AreEqual(1, filteredFunction.Components[0].Values.Count);
Assert.AreEqual(1, filteredFunction.Components[1].Values.Count);
Assert.AreEqual(100.0, filteredFunction.Components[0].Values[0]);
Assert.AreEqual(200.0, filteredFunction.Components[1].Values[0]);
}
public void SimpleReduce()
{
IVariable <int> x = new Variable <int>("x");
IVariable <int> y = new Variable <int>("y");
IVariable <int> fx = new Variable <int>("fx");
fx.Arguments.Add(x);
fx.Arguments.Add(y);
x.SetValues(new[] { 1, 2, 3 });
y.SetValues(new[] { 1 });
fx[3, 1] = 20;
var reducedFunction = fx.Filter(new VariableValueFilter <int>(y, 1), new VariableReduceFilter(y));
Assert.AreEqual(1, reducedFunction.Arguments.Count);
Assert.AreEqual(3, reducedFunction.Values.Count);
Assert.AreEqual(20, reducedFunction.Values[2]);
}
public void WriteTwoDimensionalFunctionUsingIndexFilters()
{
//writing index based now only works for adding slices..
var flow = new Variable<int>();
var x = new Variable<int>();
var y = new Variable<int>();
flow.Arguments.Add(x);
flow.Arguments.Add(y);
x.AddValues(new[] {1, 2, 3});
y.AddValues(new[] {10, 20, 30});
//we now have 3x3 array for flow..write the last 'slice'
var xIndex = new VariableIndexRangeFilter(x, 2);
var yIndex = new VariableIndexRangeFilter(y, 0, 2);
flow.SetValues(new[] {1, 2, 3}, new[] {xIndex, yIndex});
Assert.AreEqual(9, flow.Values.Count);
Assert.AreEqual(3, flow.Values[8]);
}
public void CopyDependendFunctionValuesWhenAdded()
{
//depended variable
IVariable y = new Variable <int>("y");
IVariable x = new Variable <int>("x");
y.Arguments.Add(x);
y.SetValues(new[] { 10, 20, 30 }, new VariableValueFilter <int>(x, new[] { 1, 2, 3 }));
//switch store
var store = new MemoryFunctionStore();
store.Functions.Add(y);
//get values for x and y
Assert.AreEqual(3, store.GetVariableValues(x).Count);
Assert.AreEqual(3, store.GetVariableValues(y).Count);
Assert.AreEqual(30, y[3]);
}
public void VelocityFieldFunction()
{
var x = new Variable<double> { Name = "x", Values = { 1, 2 } };
var y = new Variable<double> { Name = "y", Values = { 1, 2, 3 } };
var vx = new Variable<double> { Name = "vx" };
var vy = new Variable<double> { Name = "vy" };
var velocity = new Function { Components = { vx, vy }, Arguments = { x, y } };
vx.SetValues(new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
vy.SetValues(new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
velocity.Components[0].Should().Be.EqualTo(vx);
velocity.Components[1].Should().Be.EqualTo(vy);
velocity.Arguments[0].Should().Be.EqualTo(x);
velocity.Arguments[1].Should().Be.EqualTo(y);
vx.Values.Should().Have.SameSequenceAs(new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
vy.Values.Should().Have.SameSequenceAs(new[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
}
public void SetAndGetValuesAsArrayNonGeneric()
{
IVariable v = new Variable<double>();
v.SetValues(new[] {0.0, 0.1, 0.2});
IList values = v.Values;
Assert.AreEqual(3, v.Values.Count);
Assert.AreEqual(0.1, values[1]);
}
public void GetUniformInterpolatedValue()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
IVariable<double> f1 = new Variable<double>("f1");
f1.Arguments.Add(x);
f1.Arguments.Add(y);
var xValues = new[] { 1.0, 2.0 };
var yValues = new[] { 1.0, 2.0 };
var fValues = new[,]
{
{100.0, 100.0},
{100.0, 100.0}
};
f1.SetValues(fValues,
new VariableValueFilter<double>(x, xValues),
new VariableValueFilter<double>(y, yValues));
var value = f1.Evaluate<double>(
new VariableValueFilter<double>(x, 1.5),
new VariableValueFilter<double>(y, 1.5));
Assert.AreEqual(100,value);
}
public void IsSortedWorks()
{
IVariable<int> unsorted = new Variable<int>();
unsorted.AutoSort = false;
unsorted.SetValues(new[] { 2, 1, 3 });
Assert.AreEqual(new[]{2,1,3},unsorted.Values);
IVariable<int> sorted = new Variable<int>();
sorted.SetValues(new[] { 2, 1, 3 });
//auto sort!
Assert.AreEqual(new[] { 1, 2, 3 }, sorted.Values);
}
[Ignore("Unfinished, 15.06.2009")] // TODO: unfinished test
public void IndependendFunctionTwoComponents()
{
//every pair of c1 c2 is a value of the independed function
IVariable x = new Variable<Pair<int, double>>();
//independend function
Assert.IsTrue(x.IsIndependent);
Assert.AreEqual(2, x.Components.Count, "tuple variable is composite variables containing variable for each tuple component");
Assert.AreEqual(typeof (int), x.Components[0]);
Assert.AreEqual(typeof (double), x.Components[0]);
x.SetValues(new[]{ new Pair<int, double>(2, 1.0)});
IVariable<int> y = new Variable<int>();
y.Arguments.Add(x);
Assert.AreEqual(1,y.Values.Count);
x.SetValues(new[] { new Pair<int, double>(3, 1.0) });
Assert.AreEqual(2, y.Values.Count);
}
public void PerformanceAddValuesToArgument_UsingSetValues_WithEvents()
{
IVariable<DateTime> x = new Variable<DateTime>("x");
IVariable<double> y = new Variable<double>("y");
y.Arguments.Add(x); // make y = y(x)
const int valuesToAdd = 50000;
var t = DateTime.Now;
var xValues = new List<DateTime>();
var yValues = new List<double>();
var time = DateTime.Now;
for (var i = 0; i < valuesToAdd; i++)
{
xValues.Add(time);
yValues.Add(i);
time = time.AddDays(1);
}
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
Assert.Less(dt, 20);
t = DateTime.Now;
// TODO: split the test in 2
// now set everything in 1 step (TODO: IMPROVE PERFORMANCE HERE)
x.SetValues(xValues);
y.SetValues(yValues);
dt = DateTime.Now.Subtract(t).TotalMilliseconds;
Assert.Less(dt, 690);
log.DebugFormat("Added {0} values in {1} ms", valuesToAdd, dt);
}
public void PerformanceAddValuesToArgument_UsingSetValues_WithEvents()
{
var x = new Variable<DateTime>("x");
var y = new Variable<double>("y") { Arguments = { x } };
// prepare values
var xValues = new List<DateTime>();
var yValues = new List<double>();
const int ValuesToAdd = 50000;
var t = DateTime.Now;
var time = DateTime.Now;
for (var i = 0; i < ValuesToAdd; i++)
{
xValues.Add(time);
yValues.Add(i);
time = time.AddDays(1);
}
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Added {0} values in {1} ms", ValuesToAdd, dt);
TestHelper.AssertIsFasterThan(220, string.Format("Add {0} vlaues to function", ValuesToAdd), () =>
{
x.SetValues(xValues);
y.SetValues(yValues);
});
}
public void GetValueOfFilteredFunctionUsingValueOfFiltererArgument()
{
IVariable<double> y = new Variable<double>("y");
IVariable<double> x = new Variable<double>("x");
y.Arguments.Add(x);
x.SetValues(new[] { 1.0, 2.0, 3.0 });
y.SetValues(new[] { 10.0, 20.0, 30.0 });
var filtered = y.Filter(x.CreateValueFilter(2.0));
//arguments of filtered functions are ignored!
Assert.IsNull(filtered[3.0]);
}
public void SetValuesOnVariableWithWrongTypeShouldThrowException()
{
IVariable<float> x = new Variable<float>("x");
x.SetValues(new[] { 1.0, 2.0, 3.0 });
}
public void AddFilter()
{
IVariable<int> x = new Variable<int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
x.Filters.Add(x.CreateValuesFilter(new[] { 2, 3, 4 }));
Assert.IsTrue(x.Values.SequenceEqual(new[] { 2, 3, 4 }));
}
public void OneComponentAndNoArguments_Substance()
{
//TODO: why use a function here ????
IVariable substance = new Variable<string>("A list of substances");
substance.SetValues(new[] {"nitrogen", "oxygen", "halogens"});
Assert.AreEqual(3, substance.Values.Count);
Assert.AreEqual("nitrogen", substance.Values[0]);
Assert.AreEqual("oxygen", substance.Values[1]);
Assert.AreEqual("halogens", substance.Values[2]);
}
public void ScaleArguments()
{
var f = new Function();
IVariable<double> comp = new Variable<double>();
IVariable<double> x = new Variable<double>();
f.Components.Add(comp);
f.Arguments.Add(x);
x.SetValues(new[] {1.0, 2.0, 3.0});
Assert.IsTrue(new[] {0.0, 0.0, 0.0}.SequenceEqual(comp.Values));
}
public void Set10kFunctionValues2D_SetFirstDimensionAsLast()
{
var f = new Function();
IVariable<double> component = new Variable<double>();
IVariable<double> x = new Variable<double>();
IVariable<double> y = new Variable<double>();
f.Components.Add(component);
f.Arguments.Add(x);
f.Arguments.Add(y);
const int valuesToAddCount = 100;
var doubles = new List<double>();
for (var i = 0; i < valuesToAddCount; i++)
{
doubles.Add(i);
}
var t = DateTime.Now; // measure time
y.SetValues(doubles);
x.SetValues(doubles); // sets 10000 values for function
var dt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Added {0} values in {1} ms", valuesToAddCount * valuesToAddCount, dt);
Assert.Less(dt, 150);
}
public void CloneShouldBeFast()
{
var f = new Function();
IVariable<double> component = new Variable<double>();
IVariable<double> x = new Variable<double>();
IVariable<double> y = new Variable<double>();
f.Components.Add(component);
f.Arguments.Add(x);
f.Arguments.Add(y);
x.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
y.SetValues(new[] { 0.1, 0.2, 1, 2, 3, 4, 5, 6, 7 });
component.SetValues(new[] { 1.0 });
var t = DateTime.Now; // measure time
for (int i = 0; i < 1000; i++)
{
var f2 = f.Clone();
}
var cloneDt = DateTime.Now.Subtract(t).TotalMilliseconds;
log.DebugFormat("Cloned 2d function 10000 times in {0} ms", cloneDt);
Assert.Less(cloneDt, 700);
}
public void FilterFilteredFunction()
{
IVariable<int> x = new Variable<int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
var filtered = x.Filter(x.CreateValuesFilter(new[] { 2, 3, 4 }));
var filtered2 = filtered.Filter(x.CreateValueFilter(3));
Assert.AreEqual(3, filtered.Values.Count);
Assert.IsTrue(filtered.Values.Cast<int>().SequenceEqual(new[] { 2, 3, 4 }));
Assert.AreEqual(1, filtered2.Values.Count);
Assert.AreEqual(3, filtered2.Values[0]);
// change filters
((IVariableValueFilter)filtered2.Filters[0]).Values.Add(5);
((IVariableValueFilter)filtered2.Filters[0]).Values.Add(4);
Assert.AreEqual(2, filtered2.Values.Count);
// expanding filter in the "filtered" will also expand "filtered2"
((IVariableValueFilter)filtered.Filters[0]).Values.Add(5);
Assert.AreEqual(4, filtered.Values.Count);
Assert.AreEqual(3, filtered2.Values.Count);
}
[Test] //this used to lead to an invalid operation exception, but it should not
public void ReplaceDateTimeValue()
{
var dateTime= new DateTime(2008,1,1);
IVariable v = new Variable<DateTime>();
v.SetValues(new DateTime[]{new DateTime(2008,1,1) });
v.Values[0] = dateTime;
}
public void AddNonUniqueDateTimeValue()
{
var dateTime = new DateTime(2008, 1, 1);
IVariable v = new Variable<DateTime>();
v.SetValues(new DateTime[] { new DateTime(2008,1,1) });
//try adding non-unique value (not allowed)
v.Values.Add(dateTime);
}
public void DependentVariableValues()
{
IVariable<double> x = new Variable<double>("x");
IVariable<double> y = new Variable<double>("y");
y.Arguments.Add(x); // make y = y(x)
x.SetValues(new[] { 0.0, 0.1, 0.2 });
Assert.AreEqual(3, x.Values.Count);
Assert.AreEqual(3, y.Values.Count);
Assert.AreEqual(y.DefaultValue, y.Values[0]);
y[0.0] = 5.0d;
Assert.AreEqual(5.0,y[0.0]);
}
public void FilterIndependendVariable()
{
IVariable<int> x = new Variable<int>();
x.SetValues(new[] { 1, 2, 3, 4, 5 });
//filter out the middle
var filtered = x.Filter(x.CreateValuesFilter(new[] { 2, 3, 4 }));
Assert.AreEqual(3, filtered.Values[1]);
Assert.AreEqual(3, filtered.GetValues().Count);
}
public void VariableWithoutSort()
{
var x = new Variable<int> { IsAutoSorted = false };
var values = new[] { 2, 1, 3 };
x.SetValues(values);
Assert.AreEqual(values, x.Values, "no sorting must take place");
}
