Free cookie consent management tool by TermsFeed Policy Generator

source: stable/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval.cs @ 17495

Last change on this file since 17495 was 17495, checked in by mkommend, 4 years ago

#3032: Merged r17301, r17302, r17305, r17306, r17348, r17350, r17351 into stable.

File size: 11.1 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using HeuristicLab.Common;
26using HEAL.Attic;
27
28namespace HeuristicLab.Problems.DataAnalysis {
29  [StorableType("849e42d3-8934-419d-9aff-64ad81c06b67")]
30  public class Interval : IEquatable<Interval> {
31    [Storable]
32    public double LowerBound { get; private set; }
33    [Storable]
34    public double UpperBound { get; private set; }
35
36    [StorableConstructor]
37    protected Interval(StorableConstructorFlag _) { }
38
39    /// <summary>
40    /// Creates an interval with given bounds, where lower bound must be smaller than
41    /// the upper bound. Floating point precision errors trough calculations are fixed by,
42    /// checking if the intervals are almost the same (E-12). If this is the case, the bounds
43    /// will be set to the bound closer to zero.
44    /// </summary>
45    /// <param name="lowerBound">Lower bound of the interval</param>
46    /// <param name="upperBound">Upper bound of the interval</param>
47    public Interval(double lowerBound, double upperBound) {
48      if (lowerBound.IsAlmost(upperBound)) {
49        //If the bounds go over zero
50        if (lowerBound <= 0 && upperBound >= 0) {
51          lowerBound = 0.0;
52          upperBound = 0.0;
53          //Interval is negative
54        } else if (upperBound < 0) {
55          lowerBound = upperBound;
56          //Interval is positive
57        } else {
58          upperBound = lowerBound;
59        }
60      }
61
62      if (lowerBound > upperBound)
63        throw new ArgumentException("LowerBound must be smaller than UpperBound.");
64
65      this.LowerBound = lowerBound;
66      this.UpperBound = upperBound;
67    }
68
69    public bool Contains(double value) {
70      return LowerBound <= value && value <= UpperBound;
71    }
72
73    public override string ToString() {
74      return "Interval: [" + LowerBound + ", " + UpperBound + "]";
75    }
76
77    public bool IsInfiniteOrUndefined {
78      get {
79        return double.IsInfinity(LowerBound) || double.IsInfinity(UpperBound) ||
80                double.IsNaN(LowerBound) || double.IsNaN(UpperBound);
81      }
82    }
83
84    /// <summary>
85    /// True if the interval is positive without zero
86    /// </summary>
87    public bool IsPositive {
88      get => LowerBound > 0.0;
89    }
90
91    /// <summary>
92    /// True if the interval is negative without zero
93    /// </summary>
94    public bool IsNegative {
95      get => UpperBound < 0.0;
96    }
97
98    public static Interval GetInterval(IEnumerable<double> values) {
99      if (values == null) throw new ArgumentNullException("values");
100      if (!values.Any()) throw new ArgumentException($"No values are present.");
101
102      var min = double.MaxValue;
103      var max = double.MinValue;
104
105      foreach (var value in values) {
106        //If an value is NaN return an interval [NaN, NaN]
107        if (double.IsNaN(value)) return new Interval(double.NaN, double.NaN);
108
109        if (value < min) min = value;
110        if (value > max) max = value;
111      }
112
113      return new Interval(min, max);
114    }
115
116    #region Equals, GetHashCode, == , !=
117    public bool Equals(Interval other) {
118      if (other == null)
119        return false;
120
121      return (UpperBound.IsAlmost(other.UpperBound) || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
122        && (LowerBound.IsAlmost(other.LowerBound) || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
123    }
124
125    public override bool Equals(object obj) {
126      return Equals(obj as Interval);
127    }
128
129    public override int GetHashCode() {
130      return LowerBound.GetHashCode() ^ UpperBound.GetHashCode();
131    }
132
133    public static bool operator ==(Interval interval1, Interval interval2) {
134      if (ReferenceEquals(interval1, null)) return ReferenceEquals(interval2, null);
135      return interval1.Equals(interval2);
136    }
137    public static bool operator !=(Interval interval1, Interval interval2) {
138      return !(interval1 == interval2);
139    }
140    #endregion
141
142    #region operations
143
144    // [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
145    public static Interval Add(Interval a, Interval b) {
146      return new Interval(a.LowerBound + b.LowerBound, a.UpperBound + b.UpperBound);
147    }
148
149    // [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
150    public static Interval Subtract(Interval a, Interval b) {
151      return new Interval(a.LowerBound - b.UpperBound, a.UpperBound - b.LowerBound);
152    }
153
154    // [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
155    public static Interval Multiply(Interval a, Interval b) {
156      double v1 = a.LowerBound * b.LowerBound;
157      double v2 = a.LowerBound * b.UpperBound;
158      double v3 = a.UpperBound * b.LowerBound;
159      double v4 = a.UpperBound * b.UpperBound;
160
161      double min = Math.Min(Math.Min(v1, v2), Math.Min(v3, v4));
162      double max = Math.Max(Math.Max(v1, v2), Math.Max(v3, v4));
163      return new Interval(min, max);
164    }
165
166    //Division by intervals containing 0 is implemented as defined in
167    //http://en.wikipedia.org/wiki/Interval_arithmetic
168    public static Interval Divide(Interval a, Interval b) {
169      if (b.Contains(0.0)) {
170        if (b.LowerBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, double.PositiveInfinity));
171        else if (b.UpperBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(double.NegativeInfinity, 1.0 / b.LowerBound));
172        else return new Interval(double.NegativeInfinity, double.PositiveInfinity);
173      }
174      return Interval.Multiply(a, new Interval(1.0 / b.UpperBound, 1.0 / b.LowerBound));
175    }
176
177    public static Interval Sine(Interval a) {
178      if (Math.Abs(a.UpperBound - a.LowerBound) >= Math.PI * 2) return new Interval(-1, 1);
179
180      //divide the interval by PI/2 so that the optima lie at x element of N (0,1,2,3,4,...)
181      double Pihalf = Math.PI / 2;
182      Interval scaled = Interval.Divide(a, new Interval(Pihalf, Pihalf));
183      //move to positive scale
184      if (scaled.LowerBound < 0) {
185        int periodsToMove = Math.Abs((int)scaled.LowerBound / 4) + 1;
186        scaled = Interval.Add(scaled, new Interval(periodsToMove * 4, periodsToMove * 4));
187      }
188
189      double scaledLowerBound = scaled.LowerBound % 4.0;
190      double scaledUpperBound = scaled.UpperBound % 4.0;
191      if (scaledUpperBound < scaledLowerBound) scaledUpperBound += 4.0;
192      List<double> sinValues = new List<double>();
193      sinValues.Add(Math.Sin(scaledLowerBound * Pihalf));
194      sinValues.Add(Math.Sin(scaledUpperBound * Pihalf));
195
196      int startValue = (int)Math.Ceiling(scaledLowerBound);
197      while (startValue < scaledUpperBound) {
198        sinValues.Add(Math.Sin(startValue * Pihalf));
199        startValue += 1;
200      }
201
202      return new Interval(sinValues.Min(), sinValues.Max());
203    }
204    public static Interval Cosine(Interval a) {
205      return Interval.Sine(Interval.Add(a, new Interval(Math.PI / 2, Math.PI / 2)));
206    }
207    public static Interval Tangens(Interval a) {
208      return Interval.Divide(Interval.Sine(a), Interval.Cosine(a));
209    }
210    public static Interval HyperbolicTangent(Interval a) {
211      return new Interval(Math.Tanh(a.LowerBound), Math.Tanh(a.UpperBound));
212    }
213
214    public static Interval Logarithm(Interval a) {
215      return new Interval(Math.Log(a.LowerBound), Math.Log(a.UpperBound));
216    }
217    public static Interval Exponential(Interval a) {
218      return new Interval(Math.Exp(a.LowerBound), Math.Exp(a.UpperBound));
219    }
220
221    public static Interval Power(Interval a, Interval b) {
222      if (a.Contains(0.0) && b.LowerBound < 0) return new Interval(double.NaN, double.NaN);
223
224      int bLower = (int)Math.Round(b.LowerBound);
225      int bUpper = (int)Math.Round(b.UpperBound);
226
227      List<double> powerValues = new List<double>();
228      powerValues.Add(Math.Pow(a.UpperBound, bUpper));
229      powerValues.Add(Math.Pow(a.UpperBound, bUpper - 1));
230      powerValues.Add(Math.Pow(a.UpperBound, bLower));
231      powerValues.Add(Math.Pow(a.UpperBound, bLower + 1));
232
233      powerValues.Add(Math.Pow(a.LowerBound, bUpper));
234      powerValues.Add(Math.Pow(a.LowerBound, bUpper - 1));
235      powerValues.Add(Math.Pow(a.LowerBound, bLower));
236      powerValues.Add(Math.Pow(a.LowerBound, bLower + 1));
237
238      return new Interval(powerValues.Min(), powerValues.Max());
239    }
240
241    public static Interval Square(Interval a) {
242      if (a.UpperBound <= 0) return new Interval(a.UpperBound * a.UpperBound, a.LowerBound * a.LowerBound);     // interval is negative
243      else if (a.LowerBound >= 0) return new Interval(a.LowerBound * a.LowerBound, a.UpperBound * a.UpperBound); // interval is positive
244      else return new Interval(0, Math.Max(a.LowerBound * a.LowerBound, a.UpperBound * a.UpperBound)); // interval goes over zero
245    }
246
247    public static Interval Cube(Interval a) {
248      return new Interval(Math.Pow(a.LowerBound, 3), Math.Pow(a.UpperBound, 3));
249    }
250
251    public static Interval Root(Interval a, Interval b) {
252      int lower = (int)Math.Round(b.LowerBound);
253      int higher = (int)Math.Round(b.UpperBound);
254
255      return new Interval(Math.Pow(a.LowerBound, 1.0 / higher), Math.Pow(a.UpperBound, 1.0 / lower));
256    }
257
258    public static Interval SquareRoot(Interval a) {
259      if (a.LowerBound < 0) return new Interval(double.NaN, double.NaN);
260      return new Interval(Math.Sqrt(a.LowerBound), Math.Sqrt(a.UpperBound));
261    }
262
263    public static Interval CubicRoot(Interval a) {
264      var lower = (a.LowerBound < 0) ? -Math.Pow(-a.LowerBound, 1d / 3d) : Math.Pow(a.LowerBound, 1d / 3d);
265      var upper = (a.UpperBound < 0) ? -Math.Pow(-a.UpperBound, 1d / 3d) : Math.Pow(a.UpperBound, 1d / 3d);
266
267      return new Interval(lower, upper);
268    }
269
270    public static Interval Absolute(Interval a) {
271      var absLower = Math.Abs(a.LowerBound);
272      var absUpper = Math.Abs(a.UpperBound);
273      var min = Math.Min(absLower, absUpper);
274      var max = Math.Max(absLower, absUpper);
275
276      if (a.Contains(0.0)) {
277        min = 0.0;
278      }
279
280      return new Interval(min, max);
281    }
282
283    public static Interval AnalyticalQuotient(Interval a, Interval b) {
284      var dividend = a;
285      var divisor = Add(Square(b), new Interval(1.0, 1.0));
286      divisor = SquareRoot(divisor);
287
288      var quotient = Divide(dividend, divisor);
289      return quotient;
290    }
291    #endregion
292  }
293}
Note: See TracBrowser for help on using the repository browser.