/// <summary> /// Checks whether the value is contained in the interval /// </summary> /// <param name="interval">Checked interval</param> /// <param name="value">Checked value</param> /// <returns>True if interval contains value</returns> public static bool IsInInterval(Interval interval, long value) { if (interval.intervalType != IntervalType.Long) { throw new Exception("InvalidIntervalType"); } switch (interval.upperBoundType) { case IntervalBoundType.Round: switch (interval.lowerBoundType) { // ( , ) case IntervalBoundType.Round: if ((value > interval.lowerBound) && (value < interval.upperBound)) { return true; } else { return false; } // < , ) case IntervalBoundType.Sharp: if ((value >= interval.lowerBound) && (value < interval.upperBound)) { return true; } else { return false; } // (-inf, ) case IntervalBoundType.Infinity: if (value < interval.upperBound) { return true; } else { return false; } default: break; } break; case IntervalBoundType.Sharp: switch (interval.lowerBoundType) { // ( , > case IntervalBoundType.Round: if ((value > interval.lowerBound) && (value <= interval.upperBound)) { return true; } else { return false; } // < , > case IntervalBoundType.Sharp: if ((value >= interval.lowerBound) && (value <= interval.upperBound)) { return true; } else { return false; } //(-inf , > case IntervalBoundType.Infinity: if (value <= interval.upperBound) { return true; } else { return false; } default: break; } break; case IntervalBoundType.Infinity: switch (interval.lowerBoundType) { // ( , +inf) case IntervalBoundType.Round: if (value > interval.lowerBound) { return true; } else { return false; } // < , +inf) case IntervalBoundType.Sharp: if (value >= interval.lowerBound) { return true; } else { return false; } //(-inf , +inf) case IntervalBoundType.Infinity: return true; default: break; } break; default: break; } return false; }
/// <summary> /// Method to initialize listview using ice structures /// </summary> /// <param name="existingCategories">Categories to fill in FerdaSmartDataList</param> /// <returns>FerdaSmartDataList with categories</returns> private FerdaSmartDataList MyIceRun(Modules.CategoriesStruct existingCategories) { //here we need to fill our data structure with data from ice ArrayList allValues = new ArrayList(); if (this.distinctValues != null) { foreach (string value in this.distinctValues) { allValues.Add(value); } } FerdaSmartDataList returnList = new FerdaSmartDataList(allValues, new ArrayList()); foreach (DictionaryEntry myEnumCategorySeq in existingCategories.enums) { Category newMultiset = new Category(); newMultiset.CatType = CategoryType.Enumeration; newMultiset.Name = myEnumCategorySeq.Key.ToString(); ArrayList tempArray = new ArrayList(); String[] StringSeq = (String[])myEnumCategorySeq.Value; foreach (string entry in StringSeq) { tempArray.Add(entry); } SingleSet newSet = new SingleSet(tempArray); newMultiset.AddSingleSet(newSet); returnList.AddNewCategoryDirect(newMultiset); } foreach (DictionaryEntry myLongIntervalCategorySeq in existingCategories.longIntervals) { Category newMultiset = new Category(); newMultiset.CatType = CategoryType.Interval; newMultiset.Name = myLongIntervalCategorySeq.Key.ToString(); LongIntervalStruct[] myLongIntervalStructSeq = (LongIntervalStruct[])myLongIntervalCategorySeq.Value; foreach (LongIntervalStruct myLongIntervalStruct in myLongIntervalStructSeq) { IntervalBoundType ubt, lbt; if (myLongIntervalStruct.leftBoundType == BoundaryEnum.Infinity) { lbt = IntervalBoundType.Infinity; } else { if (myLongIntervalStruct.leftBoundType == BoundaryEnum.Round) { lbt = IntervalBoundType.Round; } else { lbt = IntervalBoundType.Sharp; } } if (myLongIntervalStruct.rightBoundType == BoundaryEnum.Infinity) { ubt = IntervalBoundType.Infinity; } else { if (myLongIntervalStruct.rightBoundType == BoundaryEnum.Round) { ubt = IntervalBoundType.Round; } else { ubt = IntervalBoundType.Sharp; } Interval newInterval = new Interval(IntervalType.Long); newInterval.lowerBound = myLongIntervalStruct.leftBound; newInterval.upperBound = myLongIntervalStruct.rightBound; newInterval.lowerBoundType = lbt; newInterval.upperBoundType = ubt; //Interval newInterval = new Interval((int)myLongIntervalStruct.leftBound, (int)myLongIntervalStruct.rightBound, lbt, ubt); // newInterval.intervalType = IntervalType.Long newMultiset.AddInterval(newInterval); } returnList.AddNewCategoryDirect(newMultiset); } } foreach (DictionaryEntry myFloatIntervalCategorySeq in existingCategories.floatIntervals) { Category newMultiset = new Category(); newMultiset.CatType = CategoryType.Interval; newMultiset.Name = myFloatIntervalCategorySeq.Key.ToString(); FloatIntervalStruct[] myFloatIntervalStructSeq = (FloatIntervalStruct[])myFloatIntervalCategorySeq.Value; foreach (FloatIntervalStruct myFloatIntervalStruct in myFloatIntervalStructSeq) { IntervalBoundType ubt, lbt; if (myFloatIntervalStruct.leftBoundType == BoundaryEnum.Infinity) { lbt = IntervalBoundType.Infinity; } else { if (myFloatIntervalStruct.leftBoundType == BoundaryEnum.Round) { lbt = IntervalBoundType.Round; } else { lbt = IntervalBoundType.Sharp; } } if (myFloatIntervalStruct.rightBoundType == BoundaryEnum.Infinity) { ubt = IntervalBoundType.Infinity; } else { if (myFloatIntervalStruct.rightBoundType == BoundaryEnum.Round) { ubt = IntervalBoundType.Round; } else { ubt = IntervalBoundType.Sharp; } Interval newInterval = new Interval(IntervalType.Float); newInterval.lowerBoundFl = myFloatIntervalStruct.leftBound; newInterval.upperBoundFl = myFloatIntervalStruct.rightBound; newInterval.lowerBoundType = lbt; newInterval.upperBoundType = ubt; // Interval newInterval = new Interval(myFloatIntervalStruct.leftBound, myFloatIntervalStruct.rightBound, lbt, ubt); newMultiset.AddInterval(newInterval); } returnList.AddNewCategoryDirect(newMultiset); } } return returnList; }
/// <summary> /// Checks whether the interval is disjunct with the current one. /// </summary> /// <param name="interval">Interval to check</param> /// <returns>Whether the checked interval is disjunct with the current one</returns> public bool IntervalIsDisjunct(Interval interval1) { bool special = false; float intervalUpperBound; float intervalLowerBound; float thisUpperBound; float thisLowerBound; if (interval1.intervalType == IntervalType.Long) { intervalUpperBound = interval1.upperBound; intervalUpperBound = (int)intervalUpperBound; intervalLowerBound = interval1.lowerBound; intervalLowerBound = (int)intervalLowerBound; thisUpperBound = this.upperBound; thisUpperBound = (int)thisUpperBound; thisLowerBound = this.lowerBound; thisLowerBound = (int)thisLowerBound; } else { if (interval1.intervalType == IntervalType.Float) { intervalUpperBound = interval1.upperBoundFl; intervalLowerBound = interval1.lowerBoundFl; thisLowerBound = this.lowerBoundFl; thisUpperBound = this.upperBoundFl; } else { return true; } } if (interval1.upperBoundType != IntervalBoundType.Infinity) { if (interval1.upperBoundType == IntervalBoundType.Sharp) { if (this.IsInInterval(intervalUpperBound)) { return false; } } else { special = true; } } else { if (this.upperBoundType != IntervalBoundType.Infinity) { if (this.upperBoundType == IntervalBoundType.Sharp) { if (interval1.IsInInterval(thisUpperBound)) { return false; } } else { special = true; } } else { //both upper bounds are infinite, cannot be disjunct return false; } } if (interval1.lowerBoundType != IntervalBoundType.Infinity) { if (interval1.lowerBoundType == IntervalBoundType.Sharp) { if (this.IsInInterval(intervalLowerBound)) { return false; } } else { special = true; } } else { if (this.lowerBoundType != IntervalBoundType.Infinity) { if (this.lowerBoundType == IntervalBoundType.Sharp) { if (interval1.IsInInterval(thisLowerBound)) { return false; } } else { special = true; } } else { //both lower bounds are minus infinity, cannot be disjunct return false; } } if (special) { if (this.upperBoundType == IntervalBoundType.Sharp) { if (interval1.IsInInterval(thisUpperBound)) { return false; } } if (this.lowerBoundType == IntervalBoundType.Sharp) { if (interval1.IsInInterval(thisLowerBound)) { return false; } } if (interval1.upperBoundType == IntervalBoundType.Infinity) { if (interval1.lowerBoundType == IntervalBoundType.Round) { if (interval1.IsInInterval(thisUpperBound)) { return false; } } if (interval1.lowerBoundType == IntervalBoundType.Sharp) { if (thisUpperBound != intervalLowerBound) { if (interval1.IsInInterval(thisUpperBound)) { return false; } } else { return false; } } } if (interval1.lowerBoundType == IntervalBoundType.Infinity) { if (interval1.upperBoundType == IntervalBoundType.Round) { if (interval1.IsInInterval(thisLowerBound)) { return false; } } if (interval1.upperBoundType == IntervalBoundType.Sharp) { if (thisLowerBound != intervalUpperBound) { if (interval1.IsInInterval(thisLowerBound)) { return false; } } else { return false; } } } if (this.upperBoundType == IntervalBoundType.Infinity) { if (this.lowerBoundType == IntervalBoundType.Round) { if (this.IsInInterval(intervalUpperBound)) { return false; } } if (this.lowerBoundType == IntervalBoundType.Sharp) { if (intervalUpperBound != thisLowerBound) { if (this.IsInInterval(intervalUpperBound)) { return false; } } else { return false; } } } if (this.lowerBoundType == IntervalBoundType.Infinity) { if (this.upperBoundType == IntervalBoundType.Round) { if (this.IsInInterval(intervalLowerBound)) { return false; } } if (this.upperBoundType == IntervalBoundType.Sharp) { if (intervalLowerBound != thisUpperBound) { if (this.IsInInterval(intervalLowerBound)) { return false; } } else { return false; } } } if ((thisLowerBound > intervalLowerBound) && (thisLowerBound < intervalUpperBound)) { return false; } if ((thisUpperBound > intervalLowerBound) && (thisUpperBound < intervalUpperBound)) { return false; } if ((intervalLowerBound > thisLowerBound) && (intervalLowerBound < thisUpperBound)) { return false; } if ((intervalUpperBound > thisLowerBound) && (intervalUpperBound < thisUpperBound)) { return false; } if ((intervalLowerBound == thisLowerBound) && (intervalUpperBound == thisUpperBound)) { return false; } } return true; }
/// <summary> /// Method to check whether the two intervals are disjunct /// </summary> /// <param name="interval1">First interval</param> /// <param name="interval2">Second interval</param> /// <returns>True if checked intervals are disjunct</returns> public static bool IntervalsAreDisjunct(Interval interval1, Interval interval2) { if (interval1.intervalType != interval2.intervalType) { throw new Exception("DifferentIntervalTypes"); } bool special = false; float int2UBFloat = 0; float int2LBFloat = 0; float int1UBFloat = 0; float int1LBFloat = 0; long int1UBLong = 0; long int2UBLong = 0; long int1LBLong = 0; long int2LBLong = 0; switch (interval1.intervalType) { case IntervalType.Long: int2UBLong = interval2.upperBound; int2LBLong = interval2.lowerBound; int1UBLong = interval1.upperBound; int1LBLong = interval1.lowerBound; break; case IntervalType.Float: int2UBFloat = interval2.upperBoundFl; int2LBFloat = interval2.lowerBoundFl; int1LBFloat = interval1.lowerBoundFl; int1UBFloat = interval1.upperBoundFl; break; default: throw new Exception("IntervalTypeNotImplemented"); } if (interval2.upperBoundType != IntervalBoundType.Infinity) { if (interval2.upperBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval1, int2UBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval1, int2UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } else { special = true; } } else { if (interval1.upperBoundType != IntervalBoundType.Infinity) { if (interval1.upperBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1UBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } else { special = true; } } else { //both upper bounds are infinite, cannot be disjunct return false; } } if (interval2.lowerBoundType != IntervalBoundType.Infinity) { if (interval2.lowerBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval1, int2LBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval1, int2LBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } else { special = true; } } else { if (interval1.lowerBoundType != IntervalBoundType.Infinity) { if (interval1.lowerBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1LBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1LBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } else { special = true; } } else { //both lower bounds are minus infinity, cannot be disjunct return false; } } if (special) { if (interval1.upperBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1UBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval1.lowerBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1LBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1LBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval2.upperBoundType == IntervalBoundType.Infinity) { if (interval2.lowerBoundType == IntervalBoundType.Round) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1UBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval2.lowerBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (int1UBLong != int2LBLong) { if (Interval.IsInInterval(interval2, int1UBLong)) { return false; } } else { return false; } break; case IntervalType.Float: if (int1UBFloat != int2LBFloat) { if (Interval.IsInInterval(interval2, int1UBFloat)) { return false; } } else { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } } if (interval2.lowerBoundType == IntervalBoundType.Infinity) { if (interval2.upperBoundType == IntervalBoundType.Round) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval2, int1LBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval2, int1LBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval2.upperBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (int1LBLong != int2UBLong) { if (Interval.IsInInterval(interval2, int1LBLong)) { return false; } } else { return false; } break; case IntervalType.Float: if (int1LBFloat != int2UBFloat) { if (Interval.IsInInterval(interval2, int1LBFloat)) { return false; } } else { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } } if (interval1.upperBoundType == IntervalBoundType.Infinity) { if (interval1.lowerBoundType == IntervalBoundType.Round) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval1, int2UBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval1, int2UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval1.lowerBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (int2UBLong != int1LBLong) { if (Interval.IsInInterval(interval1, int2UBLong)) { return false; } } else { return false; } break; case IntervalType.Float: if (int2UBFloat != int1LBFloat) { if (Interval.IsInInterval(interval1, int2UBFloat)) { return false; } } else { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } } if (interval1.lowerBoundType == IntervalBoundType.Infinity) { if (interval1.upperBoundType == IntervalBoundType.Round) { switch (interval1.intervalType) { case IntervalType.Long: if (Interval.IsInInterval(interval1, int2LBLong)) { return false; } break; case IntervalType.Float: if (Interval.IsInInterval(interval1, int2LBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } if (interval1.upperBoundType == IntervalBoundType.Sharp) { switch (interval1.intervalType) { case IntervalType.Long: if (int2LBLong != int1UBLong) { if (Interval.IsInInterval(interval1, int2LBLong)) { return false; } } else { return false; } break; case IntervalType.Float: if (int2LBFloat != int1UBFloat) { if (Interval.IsInInterval(interval1, int2LBFloat)) { return false; } } else { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } } switch (interval1.intervalType) { case IntervalType.Long: if ((int1LBLong > int2LBLong) && (int1LBLong < int2UBLong)) { return false; } if ((int1UBLong > int2LBLong) && (int1UBLong < int2UBLong)) { return false; } if ((int2LBLong > int1LBLong) && (int2LBLong < int1UBLong)) { return false; } if ((int2UBLong > int1LBLong) && (int2UBLong < int1UBLong)) { return false; } if ((int2LBLong == int1LBLong) && (int2UBLong == int1UBLong)) { return false; } break; case IntervalType.Float: if ((int1LBFloat > int2LBFloat) && (int1LBFloat < int2UBFloat)) { return false; } if ((int1UBFloat > int2LBFloat) && (int1UBFloat < int2UBFloat)) { return false; } if ((int2LBFloat > int1LBFloat) && (int2LBFloat < int1UBFloat)) { return false; } if ((int2UBFloat > int1LBFloat) && (int2UBFloat < int1UBFloat)) { return false; } if ((int2LBFloat == int1LBFloat) && (int2UBFloat == int1UBFloat)) { return false; } break; default: throw new Exception("SwitchBranchNotImplemented"); } } return true; }
/// <summary> /// Checks whether the value is contained in the interval /// </summary> /// <param name="interval">Checked interval</param> /// <param name="value">Checked value</param> /// <returns>True if interval contains value</returns> public static bool IsInInterval(Interval interval, object value) { throw new Exception("MethodNotImplemented"); }
/// <summary> /// Method to check whether one interval is disjunct with CategoriesElement values, adds it if true. /// </summary> /// <param name="interval">Interval to check and add to values if possible</param> /// <param name="values">CategoriesElement list to check and add the interval if possible</param> /// <returns>true if interval is disjunct</returns> internal static bool IntervalIsDisjunctWithCategories(Interval interval, ref List<CategoriesElement> values) { int lastSmaller = 0; int index = 0; foreach (CategoriesElement element in values) { //it is not an interval if (element.bType == IntervalBoundType.None) { switch (element.valueType) { case ElementValueType.LongValue: try { if (Interval.IsInInterval(interval, element.valLong)) { return false; } else { if (element.valLong < interval.lowerBound) { lastSmaller = index; } } } catch { throw new Exception("MixedDomain"); } break; case ElementValueType.FloatValue: try { if (Interval.IsInInterval(interval, element.valFloat)) { return false; } else { if (element.valFloat < interval.lowerBoundFl) { lastSmaller = index; } } } catch { throw new Exception("MixedDomain"); } break; case ElementValueType.DateTimeValue: throw new Exception("DateTimeNotImplemented"); default: throw new Exception("MixedDomain"); } } //it is an interval else { switch (element.valueType) { case ElementValueType.LongValue: Interval interval1 = new Interval(IntervalType.Long); interval1.lowerBound = element.valLong; interval1.lowerBoundType = element.bType; int tempIndex = values.IndexOf(element); interval1.upperBound = values[tempIndex + 1].valLong; interval1.upperBoundType = values[tempIndex + 1].bType; try { if (!Interval.IntervalsAreDisjunct(interval, interval1)) { return false; } else { if (interval1.upperBound < interval.lowerBound) { lastSmaller = index; } } } catch { throw new Exception("MixedDomain"); } break; case ElementValueType.FloatValue: Interval interval2 = new Interval(IntervalType.Float); interval2.lowerBoundFl = element.valFloat; interval2.lowerBoundType = element.bType; int tempIndex1 = values.IndexOf(element); interval2.upperBoundFl = values[tempIndex1 + 1].valFloat; interval2.upperBoundType = values[tempIndex1 + 1].bType; try { if (!Interval.IntervalsAreDisjunct(interval, interval2)) { return false; } else { if (interval2.upperBoundFl < interval.lowerBoundFl) { lastSmaller = index; } } } catch { throw new Exception("MixedDomain"); } break; case ElementValueType.DateTimeValue: throw new Exception("DateTimeNotImplemented"); default: throw new Exception("MixedDomain"); } } index++; } return false; }
/// <summary> /// To determine, if the searched interval is disjunct with all intervals in the current multiset. /// </summary> /// <param name="interval">Interval to search for</param> /// <returns>Whethter the interval is disjunct</returns> public bool IntervalIsDisjunct(Interval interval) { //searching for the value on the current level foreach (Interval interval1 in this.Intervals) { if (interval1.IntervalIsDisjunct(interval)) { return true; } } return false; }
/// <summary> /// Method to check whether any of the enum values are in interval /// </summary> /// <param name="interval"></param> /// <returns></returns> public bool IntervalDisjunctWithCurrentEnums(Interval interval) { foreach (object value in this.Set.Values) { switch (interval.intervalType) { case IntervalType.Float: try { float temp = 0; temp = (float)Convert.ToDouble(value); if (interval.IsInInterval(temp)) return false; } catch { break; } break; case IntervalType.Long: try { int temp = 0; temp = Convert.ToInt32(value); if (interval.IsInInterval(temp)) return false; } catch { break; } break; default: throw new Exception("Switch branch not implemented"); } } return true; }
/// <summary> /// Adds a new interval to the category. /// </summary> /// <param name="interval">New interval</param> public void AddInterval(Interval interval) { if (this.CatType.Equals(CategoryType.Interval)) { this.Intervals.Add(interval); } else { throw new ArgumentException("Object is not an interval"); } }