internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition == null) { return(false); } this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { try { ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable.HasValue && nullable2.HasValue) { return(true); } } return(true); }
/// <summary> /// Returns a specified value of the rule if the cell satisfies the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current value.</param> /// <returns>Returns the conditional number value.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(null); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (nullable.HasValue && nullable2.HasValue) { return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value), this.MinimumColor, this.MaximumColor)); } } return(null); }
/// <summary> /// Calculates the number. /// </summary> /// <param name="value">Value</param> /// <returns>Returns the value.</returns> internal double?CalculateNumber(object value) { try { return(new double?(ConditionValueConverter.ToDouble(value))); } catch (InvalidCastException) { return(null); } }
/// <summary> /// Calculates the formula. /// </summary> /// <param name="evaluator"></param> /// <param name="baseRow"></param> /// <param name="baseColumn"></param> /// <param name="formula">Formula</param> /// <returns>Returns the formula.</returns> internal double?CalculateFormula(ICalcEvaluator evaluator, int baseRow, int baseColumn, string formula) { object obj2 = ValueObject.FromFormula(formula).GetValue(evaluator, baseRow, baseColumn); try { return(new double?(ConditionValueConverter.ToDouble(obj2))); } catch (InvalidCastException) { return(null); } }
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition != null) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(false); } double num2 = num; double?nullable6 = nullable; if ((num2 >= ((double)nullable6.GetValueOrDefault())) || !nullable6.HasValue) { double num3 = num; double?nullable7 = nullable3; if ((num3 >= ((double)nullable7.GetValueOrDefault())) && nullable7.HasValue) { return(true); } if ((nullable.Value <= num) && (num <= nullable2.Value)) { ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value); return(true); } ScaleRule.Evaluate2Scale(num, nullable2.Value, nullable3.Value); } return(true); } } } return(false); }
/// <summary> /// Returns the specified value of the rule if the cell meets the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current value.</param> /// <returns>Returns the conditional number value.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.lastActualValue = actual; object obj2 = actual.GetValue(baseRow, baseColumn); if (obj2 != null) { double num; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(null); } double?nullable = base.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = base.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = base.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(null); } double num4 = num; double?nullable6 = nullable; if ((num4 < ((double)nullable6.GetValueOrDefault())) && nullable6.HasValue) { return(this.MinimumColor); } double num5 = num; double?nullable7 = nullable3; if ((num5 >= ((double)nullable7.GetValueOrDefault())) && nullable7.HasValue) { return(this.MaximumColor); } if ((nullable.Value <= num) && (num <= nullable2.Value)) { return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable.Value, nullable2.Value), this.MinimumColor, this.MidpointColor)); } return(ScaleRule.EvaluateColor(ScaleRule.Evaluate2Scale(num, nullable2.Value, nullable3.Value), this.MidpointColor, this.MaximumColor)); } } return(null); }
static bool TryConvertToNumber(object value, out double dValue) { dValue = 0.0; if (ConditionValueConverter.IsNumber(value)) { try { dValue = ConditionValueConverter.ToDouble(value); } catch { return(false); } return(true); } return((value is string) && double.TryParse((string)(value as string), (NumberStyles)NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture, out dValue)); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if (obj2 == null) { return(this.IgnoreBlank); } int?nullable = base.GetExpectedInt(evaluator, baseRow, baseColumn); if (nullable.HasValue) { List <double> list = null; if (this.type == Top10ConditionType.Top) { list = GetMaxValues(actualObj, nullable.Value, this.ranges); } else if (this.type == Top10ConditionType.Bottom) { list = GetMinValues(actualObj, nullable.Value, this.ranges); } if (list != null) { double num = 0.0; try { num = ConditionValueConverter.ToDouble(obj2); } catch (InvalidCastException) { return(false); } if (list.Contains(num)) { return(true); } } } return(false); }
/// <summary> /// Calculates the percentile for the specified value. /// </summary> /// <param name="evaluator"></param> /// <param name="baseRow"></param> /// <param name="baseColumn"></param> /// <param name="value">Value</param> /// <returns>Returns the percentile for the value.</returns> internal double?CalculatePercentile(ICalcEvaluator evaluator, int baseRow, int baseColumn, object value) { double?nullable = this.CalculateValue(evaluator, baseRow, baseColumn, value); if ((!nullable.HasValue || (0.0 > nullable.Value)) || (nullable.Value > 100.0)) { return(null); } double num = 0.0; foreach (CellRange range in base.Ranges) { object expression = evaluator.CreateExpression("CalcPercentileFunction", new object[] { range, (double)(nullable.Value / 100.0) }); object obj3 = evaluator.EvaluateExpression(expression, 0, 0, baseRow, baseColumn, false); try { num += ConditionValueConverter.ToDouble(obj3); } catch (InvalidCastException) { } } return(new double?(num / ((double)base.Ranges.Length))); }
/// <summary> /// Checks the condition. /// </summary> /// <param name="expectedValue">Expected value for the condition.</param> /// <param name="actualValue">Actual value for the condition.</param> /// <returns> /// <c>true</c> if the value satisfies the condition; otherwise, <c>false</c>. /// </returns> bool CheckCondition(object expectedValue, object actualValue) { double dValue = 0.0; bool flag = false; if (expectedValue is bool) { bool @this = (bool)((bool)expectedValue); switch (this.compareType) { case GeneralCompareType.EqualsTo: return(object.Equals(actualValue, expectedValue)); case GeneralCompareType.NotEqualsTo: return(!object.Equals(actualValue, expectedValue)); case GeneralCompareType.GreaterThan: if (@this.CompareTo(actualValue) >= 0) { return(false); } return(true); case GeneralCompareType.GreaterThanOrEqualsTo: if (@this.CompareTo(actualValue) > 0) { return(false); } return(true); case GeneralCompareType.LessThan: if (@this.CompareTo(actualValue) <= 0) { return(false); } return(true); case GeneralCompareType.LessThanOrEqualsTo: if (@this.CompareTo(actualValue) < 0) { return(false); } return(true); } } if (actualValue is TimeSpan) { TimeSpan span = (TimeSpan)actualValue; dValue = span.TotalSeconds; flag = true; } else { flag = TryConvertToNumber(actualValue, out dValue); } if ((actualValue == null) && (expectedValue == null)) { switch (this.compareType) { case GeneralCompareType.EqualsTo: case GeneralCompareType.GreaterThanOrEqualsTo: case GeneralCompareType.LessThanOrEqualsTo: return(true); case GeneralCompareType.NotEqualsTo: case GeneralCompareType.GreaterThan: case GeneralCompareType.LessThan: return(false); } return(false); } if (this.TreatNullValueAsZero && (actualValue == null)) { flag = true; dValue = 0.0; } if (flag) { double totalSeconds = 0.0; try { if (expectedValue is DateTime) { totalSeconds = ((DateTime)expectedValue).ToOADate(); } else if (expectedValue is TimeSpan) { TimeSpan span2 = (TimeSpan)expectedValue; totalSeconds = span2.TotalSeconds; } else { totalSeconds = ConditionValueConverter.ToDouble(expectedValue); } } catch { switch (this.CompareType) { case GeneralCompareType.EqualsTo: return(false); case GeneralCompareType.NotEqualsTo: return(true); } return(false); } switch (this.CompareType) { case GeneralCompareType.EqualsTo: return(dValue == totalSeconds); case GeneralCompareType.NotEqualsTo: return(!(dValue == totalSeconds)); case GeneralCompareType.GreaterThan: return(dValue > totalSeconds); case GeneralCompareType.GreaterThanOrEqualsTo: return(dValue >= totalSeconds); case GeneralCompareType.LessThan: return(dValue < totalSeconds); case GeneralCompareType.LessThanOrEqualsTo: return(dValue <= totalSeconds); } } else if (actualValue is string) { string str = null; if (expectedValue is string) { str = (string)(expectedValue as string); } else { switch (this.CompareType) { case GeneralCompareType.EqualsTo: return(false); case GeneralCompareType.NotEqualsTo: return(true); } return(false); } string strB = (string)((string)actualValue); switch (this.CompareType) { case GeneralCompareType.EqualsTo: return(strB == str); case GeneralCompareType.NotEqualsTo: return(strB != str); case GeneralCompareType.GreaterThan: return(str.CompareTo(strB) < 0); case GeneralCompareType.GreaterThanOrEqualsTo: return(str.CompareTo(strB) <= 0); case GeneralCompareType.LessThan: return(str.CompareTo(strB) > 0); case GeneralCompareType.LessThanOrEqualsTo: return(str.CompareTo(strB) >= 0); } } return(false); }
/// <summary> /// Evaluates using the specified evaluator. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The base row.</param> /// <param name="baseColumn">The base column.</param> /// <param name="actualObj">The actual value object.</param> /// <returns><c>true</c> if the result is successful; otherwise, <c>false</c>.</returns> public override bool Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actualObj) { object obj2 = actualObj.GetValue(); if (this.IgnoreBlank && (obj2 == null)) { return(true); } this.RebuildFormula(evaluator); double?nullable = base.GetExpectedDouble(evaluator, baseRow, baseColumn); double?nullable2 = null; object val = (this.stdValueObject != null) ? this.stdValueObject.GetValue(evaluator, baseRow, baseColumn) : null; if (val != null) { nullable2 = ConditionValueConverter.TryDouble(val); } if (ConditionValueConverter.IsNumber(obj2)) { double num = ConditionValueConverter.ToDouble(obj2); if (nullable.HasValue) { switch (this.type) { case AverageConditionType.Above: return(num > nullable.Value); case AverageConditionType.Below: return(num < nullable.Value); case AverageConditionType.EqualOrAbove: return(num >= nullable.Value); case AverageConditionType.EqualOrBelow: return(num <= nullable.Value); case AverageConditionType.Above1StdDev: { this.stdValueObject.GetValue(evaluator, baseRow, baseColumn); if (!nullable2.HasValue) { return(false); } double num2 = num; double?nullable3 = nullable; double num3 = nullable2.Value; double?nullable5 = nullable3.HasValue ? new double?(((double)nullable3.GetValueOrDefault()) + num3) : null; if (num2 <= ((double)nullable5.GetValueOrDefault())) { return(false); } return(nullable5.HasValue); } case AverageConditionType.Below1StdDev: { if (!nullable2.HasValue) { return(false); } double num4 = num; double?nullable6 = nullable; double num5 = nullable2.Value; double?nullable8 = nullable6.HasValue ? new double?(((double)nullable6.GetValueOrDefault()) - num5) : null; if (num4 >= ((double)nullable8.GetValueOrDefault())) { return(false); } return(nullable8.HasValue); } case AverageConditionType.Above2StdDev: { if (!nullable2.HasValue) { return(false); } double num6 = num; double?nullable9 = nullable; double num7 = 2.0 * nullable2.Value; double?nullable11 = nullable9.HasValue ? new double?(((double)nullable9.GetValueOrDefault()) + num7) : null; if (num6 <= ((double)nullable11.GetValueOrDefault())) { return(false); } return(nullable11.HasValue); } case AverageConditionType.Below2StdDev: { if (!nullable2.HasValue) { return(false); } double num8 = num; double?nullable12 = nullable; double num9 = 2.0 * nullable2.Value; double?nullable14 = nullable12.HasValue ? new double?(((double)nullable12.GetValueOrDefault()) - num9) : null; if (num8 >= ((double)nullable14.GetValueOrDefault())) { return(false); } return(nullable14.HasValue); } case AverageConditionType.Above3StdDev: { if (!nullable2.HasValue) { return(false); } double num10 = num; double?nullable15 = nullable; double num11 = 3.0 * nullable2.Value; double?nullable17 = nullable15.HasValue ? new double?(((double)nullable15.GetValueOrDefault()) + num11) : null; if (num10 <= ((double)nullable17.GetValueOrDefault())) { return(false); } return(nullable17.HasValue); } case AverageConditionType.Below3StdDev: { if (!nullable2.HasValue) { return(false); } double num12 = num; double?nullable18 = nullable; double num13 = 3.0 * nullable2.Value; double?nullable20 = nullable18.HasValue ? new double?(((double)nullable18.GetValueOrDefault()) - num13) : null; if (num12 >= ((double)nullable20.GetValueOrDefault())) { return(false); } return(nullable20.HasValue); } } } } return(false); }
/// <summary> /// Checks the condition. /// </summary> /// <param name="expectedValue">Expected value for the condition.</param> /// <param name="actualValue">Actual value for the condition.</param> /// <returns> /// <c>true</c> if the value satisfies the condition; otherwise, <c>false</c>. /// </returns> bool CheckCondition(object expectedValue, object actualValue) { if (this.IgnoreBlank && ((actualValue == null) || actualValue.Equals(string.Empty))) { return(true); } if (ConditionValueConverter.IsNumber(actualValue)) { double?nullable = null; object obj2 = expectedValue; if (obj2 is string) { return((this.CompareType == GeneralCompareType.NotEqualsTo) && ConditionValueConverter.IsNumber(actualValue)); } if (ConditionValueConverter.IsNumber(obj2)) { nullable = new double?(ConditionValueConverter.ToDouble(obj2)); } if (!nullable.HasValue) { if (this.IgnoreBlank) { return(true); } nullable = 0.0; } double d = 0.0; try { d = ConditionValueConverter.ToDouble(actualValue); } catch (FormatException) { return(false); } if (!this.IntegerValue || ((d - Math.Floor(d)) == 0.0)) { switch (this.CompareType) { case GeneralCompareType.EqualsTo: return(d == nullable.Value); case GeneralCompareType.NotEqualsTo: return(d != nullable.Value); case GeneralCompareType.GreaterThan: return(d > nullable.Value); case GeneralCompareType.GreaterThanOrEqualsTo: return(d >= nullable.Value); case GeneralCompareType.LessThan: return(d < nullable.Value); case GeneralCompareType.LessThanOrEqualsTo: return(d <= nullable.Value); } } } return(false); }
internal override bool IsConditionEvaluateToTrue(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { if (base.condition != null) { this.TryCache(actual); if (base.Contains(baseRow, baseColumn)) { object obj2 = actual.GetValue(); if (obj2 == null) { return(false); } try { double num = ConditionValueConverter.ToDouble(obj2); double?nullable = this.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = this.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (!nullable2.HasValue) { if (nullable.HasValue && nullable3.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(false); } return(true); } } else if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable6 = nullable; double?nullable7 = nullable3; if ((((double)nullable6.GetValueOrDefault()) > ((double)nullable7.GetValueOrDefault())) && (nullable6.HasValue & nullable7.HasValue)) { return(false); } double num2 = num; double?nullable8 = nullable; if ((num2 >= ((double)nullable8.GetValueOrDefault())) || !nullable8.HasValue) { double num3 = num; double?nullable9 = nullable3; if ((num3 >= ((double)nullable9.GetValueOrDefault())) && nullable9.HasValue) { return(true); } Evaluate2Scale(nullable2.Value, nullable.Value, nullable3.Value); if ((nullable.Value <= num) && (num <= nullable2.Value)) { return(true); } } return(true); } } catch { return(false); } } } return(false); }
/// <summary> /// Evaluates a specified value of the rule if the cell satisfies the condition. /// </summary> /// <param name="evaluator">The evaluator.</param> /// <param name="baseRow">The row index.</param> /// <param name="baseColumn">The column index.</param> /// <param name="actual">The current value.</param> /// <returns>Returns the conditional number value.</returns> public override object Evaluate(ICalcEvaluator evaluator, int baseRow, int baseColumn, IActualValue actual) { this.TryCache(actual); if (base.Contains(baseRow, baseColumn)) { object obj2 = actual.GetValue(); if (obj2 == null) { return(null); } try { double num = ConditionValueConverter.ToDouble(obj2); double?nullable = this.GetActualValue(evaluator, baseRow, baseColumn, 0, actual); double?nullable2 = this.GetActualValue(evaluator, baseRow, baseColumn, 1, actual); double?nullable3 = this.GetActualValue(evaluator, baseRow, baseColumn, 2, actual); if (!nullable2.HasValue) { if (nullable.HasValue && nullable3.HasValue) { double?nullable4 = nullable; double?nullable5 = nullable3; if ((((double)nullable4.GetValueOrDefault()) > ((double)nullable5.GetValueOrDefault())) && (nullable4.HasValue & nullable5.HasValue)) { return(null); } return((double)Evaluate2Scale(num, nullable.Value, nullable3.Value)); } } else if ((nullable.HasValue && nullable3.HasValue) && nullable2.HasValue) { double?nullable6 = nullable; double?nullable7 = nullable3; if ((((double)nullable6.GetValueOrDefault()) > ((double)nullable7.GetValueOrDefault())) && (nullable6.HasValue & nullable7.HasValue)) { return(null); } double num5 = num; double?nullable8 = nullable; if ((num5 < ((double)nullable8.GetValueOrDefault())) && nullable8.HasValue) { return((double)0.0); } double num6 = num; double?nullable9 = nullable3; if ((num6 >= ((double)nullable9.GetValueOrDefault())) && nullable9.HasValue) { return((double)2.0); } Evaluate2Scale(nullable2.Value, nullable.Value, nullable3.Value); if ((nullable.Value <= num) && (num <= nullable2.Value)) { return((double)Evaluate2Scale(num, nullable.Value, nullable2.Value)); } double num4 = 1.0 + Evaluate2Scale(num, nullable.Value, nullable3.Value); return((double)num4); } } catch { return(null); } } return(null); }