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