source: branches/2966_interval_calculation/IntervalArithmeticTest.cs @ 16351

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using HeuristicLab.Algorithms.DataAnalysis.IntervalArithmetic;
using HeuristicLab.Problems.DataAnalysis.Symbolic;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;

namespace Test {
    [TestClass]
    public class IntervalArithmeticTest {
        private TestContext testContextInstance;
        public TestContext TestContext {
            get { return testContextInstance; }
            set { testContextInstance = value; }
        }

        private Interval a = new Interval(-1, 1);
        private Interval b = new Interval(-2, 2);
        private Interval c = new Interval(0, 3);
        private Interval d = new Interval(1, 3);
        private Interval e = new Interval(4, 6);
        private IRegressionProblemData problemData;
        private Dictionary<string, Interval> customIntervals;

        [TestInitialize]
        public void InitTest() {
            double[,] arr = new double[4, 3];
            customIntervals = new Dictionary<string, Interval>();

            arr[0, 0] = 3;
            arr[0, 1] = 6;
            arr[0, 2] = 2;
            arr[1, 0] = 5;
            arr[1, 1] = 2;
            arr[1, 2] = 1;
            arr[2, 0] = 8;
            arr[2, 1] = 5;
            arr[2, 2] = 0;
            arr[3, 0] = 3;
            arr[3, 1] = 4;
            arr[3, 2] = 2;

            customIntervals.Add("x1", new Interval(1, 10));
            customIntervals.Add("x2", new Interval(4, 6));


            var ds = new Dataset(new string[] { "x1", "x2", "y" }, arr);
            problemData = (IRegressionProblemData)new RegressionProblemData(ds, new string[] { "x1", "x2" }, "y");
        }

        [TestMethod]
        public void TestIntervalAddOperation() {
            //add        [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
            Assert.AreEqual<Interval>(Interval.Add(a, b), new Interval(-3, 3));
            Assert.AreEqual<Interval>(Interval.Add(Interval.Add(a, b), c), new Interval(-3, 6));
            Assert.AreEqual<Interval>(Interval.Add(Interval.Add(a, c), b), new Interval(-3, 6));
        }

        [TestMethod]
        public void TestIntervalSubOperation() {
            //subtract   [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
            Assert.AreEqual<Interval>(Interval.Subtract(a, b), new Interval(-3, 3));
            Assert.AreEqual<Interval>(Interval.Subtract(Interval.Subtract(a, b), c), new Interval(-6, 3));
            Assert.AreEqual<Interval>(Interval.Subtract(Interval.Subtract(a, c), b), new Interval(-6, 3));
        }

        [TestMethod]
        public void TestIntervalMutlipyOperation() {
            //multiply   [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
            Assert.AreEqual<Interval>(Interval.Multiply(a, b), new Interval(-2, 2));
            Assert.AreEqual<Interval>(Interval.Multiply(Interval.Multiply(a, b), c), new Interval(-6, 6));
            Assert.AreEqual<Interval>(Interval.Multiply(Interval.Multiply(a, c), b), new Interval(-6, 6));
        }

        [TestMethod]
        public void TestIntervalDivideOperation() {
            //divide  [x1, x2] / [y1, y2] = [x1, x2] * (1/[y1, y2]), where 1 / [y1,y2] = [1 / y2,1 / y1] if 0 not in [y_1, y_2].
            Assert.AreEqual<Interval>(Interval.Divide(e, d), new Interval(4.0 / 3.0, 6));
            Assert.AreEqual<Interval>(Interval.Divide(Interval.Divide(e, d), d), new Interval(4.0 / 9.0, 6));
            Assert.AreEqual<Interval>(Interval.Divide(e, c), new Interval(4.0 / 3.0, double.PositiveInfinity));
            Assert.AreEqual<Interval>(Interval.Divide(a, c), new Interval(double.NegativeInfinity, double.PositiveInfinity));
            Assert.IsTrue(Interval.Divide(e, c).IsInfiniteOrUndefined);
            Assert.IsTrue(Interval.Divide(a, c).IsInfiniteOrUndefined);
            Assert.AreEqual<Interval>(Interval.Divide(d, b), new Interval(double.NegativeInfinity, double.PositiveInfinity));
        }

        [TestMethod]
        public void TestIntervalSineOperator() {
            //sine depdends on interval
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(-1 * Math.PI / 2, Math.PI / 2)), new Interval(-1, 1));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(0, Math.PI / 2)), new Interval(0, 1));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(Math.PI, 3 * Math.PI / 2)), new Interval(-1, 0));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(1, 2)), new Interval(Math.Min(Math.Sin(1), Math.Sin(2)), 1));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(1, 3)), new Interval(Math.Min(Math.Sin(1), Math.Sin(3)), 1));
            Assert.AreEqual<Interval>(Interval.Sine(new Interval(Math.PI, 5 * Math.PI / 2)), new Interval(-1, 1));
        }

        [TestMethod]
        public void TestIntervalCosineOperator() {
            Assert.AreEqual<Interval>(Interval.Cosine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
            Assert.AreEqual<Interval>(new Interval(-1, 1), Interval.Cosine(new Interval(Math.PI, 4 * Math.PI / 2)));
        }

        [TestMethod]
        public void TestIntervalLogOperator() {
            Assert.AreEqual<Interval>(new Interval(Math.Log(3), Math.Log(5)), Interval.Logarithm(new Interval(3, 5)));
            Assert.AreEqual<Interval>(new Interval(Math.Log(0.5), 0), Interval.Logarithm(new Interval(0.5, 1)));
        }

        [TestMethod]
        public void TestIntervalExpOperator() {
            Assert.AreEqual<Interval>(new Interval(1, Math.Exp(1)), Interval.Exponential(new Interval(0, 1)));
        }


        [TestMethod]
        public void TestIntervalCalculationAdd() {
            var stringRepresentation = "x1 + x2";
            var parser = new InfixExpressionParser();
            var tree = parser.Parse(stringRepresentation);
            var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
            var result = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.AllIndices);

            Assert.AreEqual(new Interval(5, 14), result);
        }

        [TestMethod]
        public void TestIntervalCalculationLogAdd() {
            var stringRepresentation = "log(x1 + x2)";
            var parser = new InfixExpressionParser();
            var tree = parser.Parse(stringRepresentation);
            var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
            var result = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.AllIndices);

            Assert.AreEqual(new Interval(Math.Log(5), Math.Log(14)), result);
        }

        [TestMethod]
        public void TestIntervalCalculationLogAddMul() {
            var stringRepresentation = "log(3*x1 + x2)";
            var parser = new InfixExpressionParser();
            var tree = parser.Parse(stringRepresentation);
            var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
            var result = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.AllIndices);

            Assert.AreEqual(new Interval(Math.Log(11), Math.Log(30)), result);
        }

        [TestMethod]
        public void TestProblemDataIndices() {
            var stringRepresentation = "x1 + x2";
            var parser = new InfixExpressionParser();
            var tree = parser.Parse(stringRepresentation);
            var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
            var x = problemData.TestIndices;
            var result = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.TrainingIndices);

            Assert.AreEqual(new Interval(5, 11), result);
        }

        [TestMethod]
        public void TestCustomIntervals() {
            var stringRepresentation = "x1 + x2";
            var parser = new InfixExpressionParser();
            var tree = parser.Parse(stringRepresentation);
            var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
            var x = problemData.TestIndices;
            var result = interpreter.GetSymbolicExpressionTreeValues(tree, problemData.Dataset, problemData.TrainingIndices, customIntervals);

            Assert.AreEqual(new Interval(5, 16), result);
        }
    }
}