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