private IDictionary <int, IList <int> > FindAll(string match) { bool searchInSelection = HightlightedCellsBackground.Values.Sum(list => list.Count) > 1; ComparisonOperation comparisonOperation = findAndReplaceDialog.GetComparisonOperation(); var foundCells = new Dictionary <int, IList <int> >(); for (int i = 0; i < Content.FilterLogic.PreprocessingData.Columns; i++) { var filters = CreateFilters(match, comparisonOperation, i); bool[] filteredRows = Content.FilterLogic.GetFilterResult(filters, true); var foundIndices = new List <int>(); for (int idx = 0; idx < filteredRows.Length; ++idx) { var notFilteredThusFound = !filteredRows[idx]; if (notFilteredThusFound) { foundIndices.Add(idx); } } foundCells[i] = foundIndices; IList <int> selectedList; if (searchInSelection && HightlightedCellsBackground.TryGetValue(i, out selectedList)) { foundCells[i] = foundCells[i].Intersect(selectedList).ToList <int>(); } else if (searchInSelection) { foundCells[i].Clear(); } } return(MapToSorting(foundCells)); }
public static ExprBinaryOp GetExprComparison(Expr left, Expr right, ComparisonOperation op) { if (op == ComparisonOperation.Equals) { return(new OData.ExprEquals(left, right)); } else if (op == ComparisonOperation.NotEquals) { return(new OData.ExprNotEquals(left, right)); } else if (op == ComparisonOperation.GreaterThan) { return(new OData.ExprGreaterThan(left, right)); } else if (op == ComparisonOperation.GreaterThanOrEquals) { return(new OData.ExprGreaterThanOrEquals(left, right)); } else if (op == ComparisonOperation.LesserThan) { return(new OData.ExprLesserThan(left, right)); } else if (op == ComparisonOperation.LesserThanOrEquals) { return(new OData.ExprLesserThanOrEquals(left, right)); } throw new System.ArgumentOutOfRangeException(); }
private List <IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex) { IPreprocessingData preprocessingData = Content.FilterLogic.PreprocessingData; IStringConvertibleValue value; if (preprocessingData.VariableHasType <double>(columnIndex)) { value = new DoubleValue(); } else if (preprocessingData.VariableHasType <String>(columnIndex)) { value = new StringValue(); } else if (preprocessingData.VariableHasType <DateTime>(columnIndex)) { value = new DateTimeValue(); } else { throw new ArgumentException("unsupported type"); } value.SetValue(match); var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true); comparisonFilter.ConstraintColumn = columnIndex; return(new List <Filter.IFilter>() { comparisonFilter }); }
public ComparisonExpression(ComparisonOperation op, TextExpression exp1, TextExpression exp2) { this._op = op; this._exp1 = exp1; this._exp2 = exp2; this.RawValue = exp1.RawValue + (object)op + exp2.RawValue; }
private bool ConsumeComparisonExpression() { TokenType tokenType1 = this.LookAheadFirst.TokenType; TokenType tokenType2 = this.LookAheadSecond.TokenType; if (!this.IsArithmeticExpression(tokenType1) || !this.IsComparisonOperator(tokenType2)) { return(false); } TextExpression lookAheadFirst1 = this.LookAheadFirst; this.DiscardToken(); ComparisonOperation comparisonOp = this.GetComparisonOp(tokenType2); this.DiscardToken(); do { ; }while (this.DoExpressionRules()); if (!this.IsArithmeticExpression(this.LookAheadFirst.TokenType)) { return(false); } TextExpression lookAheadFirst2 = this.LookAheadFirst; this.DiscardToken(); this.PushToken((TextExpression) new ComparisonExpression(comparisonOp, lookAheadFirst1, lookAheadFirst2)); return(true); }
private Core.ConstraintOperation GetConstraintOperation(ComparisonOperation comparisonOperation) { Core.ConstraintOperation constraintOperation = Core.ConstraintOperation.Equal; switch (comparisonOperation) { case ComparisonOperation.Equal: constraintOperation = Core.ConstraintOperation.Equal; break; case ComparisonOperation.Greater: constraintOperation = Core.ConstraintOperation.Greater; break; case ComparisonOperation.GreaterOrEqual: constraintOperation = Core.ConstraintOperation.GreaterOrEqual; break; case ComparisonOperation.Less: constraintOperation = Core.ConstraintOperation.Less; break; case ComparisonOperation.LessOrEqual: constraintOperation = Core.ConstraintOperation.LessOrEqual; break; case ComparisonOperation.NotEqual: constraintOperation = Core.ConstraintOperation.NotEqual; break; } return(constraintOperation); }
// ******************************************************************** public static bool RunComparison(ComparisonOperation _comparison, float _first, float _second) { switch (_comparison) { case ComparisonOperation.EQUAL: return(_first == _second); case ComparisonOperation.NOT_EQUAL: return(_first != _second); case ComparisonOperation.GREATER_THAN: return(_first > _second); case ComparisonOperation.GREATER_THAN_EQUAL_TO: return(_first >= _second); case ComparisonOperation.LESS_THAN: return(_first < _second); case ComparisonOperation.LESS_THAN_EQUAL_TO: return(_first <= _second); default: Debug.LogError("Invalid comparison operation provided: " + _comparison); return(false); } }
public void ComparisonOperation_GetterWorksProperly() { // Act ComparisonOperation actualComparisonOperation = _unaryStatement.ComparisonOperation; // Assert Assert.AreEqual(_expectedComparisonOperation, actualComparisonOperation); }
public ConditionPreviousRank(XElement el) { if (el == null) { throw new ArgumentNullException("el"); } Rank = RankManager.ParseRank(el.Attribute("val").Value); Comparison = (ComparisonOperation)Enum.Parse(typeof(ComparisonOperation), el.Attribute("op").Value, true); }
public static string GetComparisonOperator(ComparisonOperation comparisonOperation) { if (!ComparisonOperators.Keys.Contains(comparisonOperation)) { throw new InvalidOperationException("Required operation was not recognized."); } return ComparisonOperators[comparisonOperation]; }
public void Visit(ComparisonOperation node) { BinaryOperationVisit(node); if (special_object_return_type) { IC.Add(new CommentLine($"set bool as return type")); IC.Add(new AssignmentStringToVariable(return_type_variable, "Bool")); } }
public static string GetComparisonOperator(ComparisonOperation comparisonOperation) { if (!ComparisonOperators.Keys.Contains(comparisonOperation)) { throw new InvalidOperationException("Required operation was not recognized."); } return(ComparisonOperators[comparisonOperation]); }
private static bool Compare(ComparisonOperation op, object var1, object var2) { dynamic v1 = var1; dynamic v2 = var2; if (v1 == null && v2 == null) { return(op == ComparisonOperation.Equality || op == ComparisonOperation.GreaterThanOrEqualTo || op == ComparisonOperation.LessThanOrEqualTo); } if (v1 == null || v2 == null) { return(op == ComparisonOperation.Inequality); } if (v1 is bool && v2 is bool) // Handle boolean comparison in a separate method. { return(CompareBoolean(op, (bool)v1, (bool)v2)); } // Handle comparisons between boolean and numeric values. if (v1 is bool) { return(CompareBoolean(op, (bool)v1, v2 != 0)); } if (v2 is bool) { return(CompareBoolean(op, (bool)v2, v1 != 0)); } // Match up decimal/double types. TypeMatch(ref v1, ref v2); switch (op) { case ComparisonOperation.Equality: return(v1 == v2); case ComparisonOperation.Inequality: return(v1 != v2); case ComparisonOperation.GreaterThan: return(v1 > v2); case ComparisonOperation.LessThan: return(v1 < v2); case ComparisonOperation.GreaterThanOrEqualTo: return(v1 >= v2); case ComparisonOperation.LessThanOrEqualTo: return(v1 <= v2); default: throw new ArgumentOutOfRangeException(nameof(op), op, null); } }
public ConditionIntRange( XElement el ) { if( el == null ) throw new ArgumentNullException( "el" ); Field = (ConditionField)Enum.Parse( typeof( ConditionField ), el.Attribute( "field" ).Value, true ); Value = Int32.Parse( el.Attribute( "val" ).Value ); if( el.Attribute( "op" ) != null ) { Comparison = (ComparisonOperation)Enum.Parse( typeof( ComparisonOperation ), el.Attribute( "op" ).Value, true ); } if( el.Attribute( "scope" ) != null ) { Scope = (ConditionScopeType)Enum.Parse( typeof( ConditionScopeType ), el.Attribute( "scope" ).Value, true ); } }
public void TestAppendString(ComparisonOperation op, string expected) { var variable = new VariableExpression("variable"); var value = new IntegerConstantExpression(99); var expr = new ComparisonExpression(variable, op, value); var builder = new StringBuilder(); expr.AppendString(builder); Assert.That(builder.ToString(), Is.EqualTo(expected)); }
/// <summary> /// Used to create: {ValueLeft}{ComparisonOperator}{ValueRight} /// </summary> public Expression(ComparisonOperation comparisonOperation, IValueType valueLeft, IValueType valueRight) { StringBuilder sb = new StringBuilder(512); this._comparisonOperator = Operation.GetComparisonOperator(comparisonOperation); sb.Append(valueLeft.ToString()); sb.Append(this._comparisonOperator); sb.Append(valueRight.ToString()); this.Value = sb.ToString(); }
/// <summary> /// Used to create: {ValueLeft}{ComparisonOperator}{ValueRight} /// </summary> public Expression(ComparisonOperation comparisonOperation, IValueType valueLeft, IValueType valueRight) { StringBuilder sb = new StringBuilder(512); this.ComparisonOperator = Operation.GetComparisonOperator(comparisonOperation); sb.Append(valueLeft.ToString()); sb.Append(this.ComparisonOperator); sb.Append(valueRight.ToString()); this.Value = sb.ToString(); }
public ConditionPreviousRank(Rank rank, ComparisonOperation comparison) { if (rank == null) { throw new ArgumentNullException("rank"); } if (!Enum.IsDefined(typeof(ComparisonOperation), comparison)) { throw new ArgumentOutOfRangeException("comparison", "Unknown comparison type"); } Rank = rank; Comparison = comparison; }
private string GetComparisonExpressionFormat(ComparisonOperation operation) { switch (operation) { case ComparisonOperation.Between: return("{0} <= {1} and {1} <= {2}"); case ComparisonOperation.NotBetween: return("{0} > {1} or {1} > {2}"); default: throw new ArgumentOutOfRangeException(operation.ToString() + " is not a supported linear operation."); } }
private static bool CompareBoolean(ComparisonOperation op, bool var1, bool var2) { // ReSharper disable once SwitchStatementMissingSomeCases switch (op) { case ComparisonOperation.Equality: return(var1 == var2); case ComparisonOperation.Inequality: return(var1 != var2); default: throw new InvalidVariableOperationException($"Attempted to perform an {op} operation on a boolean value."); } }
public void Visit(ComparisonOperation node) { node.LeftOperand.Accept(this); node.RightOperand.Accept(this); if (node.LeftOperand.StaticType.Text != "Int" || node.RightOperand.StaticType.Text != "Int") { errors.Add(SemanticError.InvalidUseOfOperator(node, node.LeftOperand.StaticType, node.RightOperand.StaticType)); } if (!scope.IsDefinedType("Bool", out node.StaticType)) { errors.Add(SemanticError.NotDeclaredType(new TypeNode(node.Line, node.Column, "Bool"))); } }
public UnaryStatement(string leftOperand, ComparisonOperation comparisonOperation, string rightOperand) { if (string.IsNullOrWhiteSpace(leftOperand)) { throw new ArgumentNullException(nameof(leftOperand)); } if (string.IsNullOrWhiteSpace(rightOperand)) { throw new ArgumentNullException(nameof(rightOperand)); } LeftOperand = leftOperand; ComparisonOperation = comparisonOperation; RightOperand = rightOperand; }
void findAndReplaceDialog_FindNextEvent(object sender, EventArgs e) { if (searchIterator == null || currentSearchText != findAndReplaceDialog.GetSearchText() || currentComparisonOperation != findAndReplaceDialog.GetComparisonOperation()) { searchIterator = new FindPreprocessingItemsIterator(FindAll(findAndReplaceDialog.GetSearchText())); currentSearchText = findAndReplaceDialog.GetSearchText(); currentComparisonOperation = findAndReplaceDialog.GetComparisonOperation(); } if (IsOneCellSelected()) { var first = GetSelectedCells().First(); searchIterator.SetStartCell(first.Key, first.Value[0]); } bool moreOccurences = false; currentCell = searchIterator.GetCurrent(); moreOccurences = searchIterator.MoveNext(); if (IsOneCellSelected() && currentCell != null) { var first = GetSelectedCells().First(); if (currentCell.Item1 == first.Key && currentCell.Item2 == first.Value[0]) { if (!moreOccurences) { searchIterator.Reset(); } currentCell = searchIterator.GetCurrent(); moreOccurences = searchIterator.MoveNext(); if (!moreOccurences) { searchIterator.Reset(); } } } dataGridView.ClearSelection(); if (currentCell != null) { dataGridView[currentCell.Item1, currentCell.Item2].Selected = true; dataGridView.CurrentCell = dataGridView[currentCell.Item1, currentCell.Item2]; } }
public ConditionIntRange(XElement el) { if (el == null) { throw new ArgumentNullException("el"); } Field = (ConditionField)Enum.Parse(typeof(ConditionField), el.Attribute("field").Value, true); Value = Int32.Parse(el.Attribute("val").Value); if (el.Attribute("op") != null) { Comparison = (ComparisonOperation)Enum.Parse(typeof(ComparisonOperation), el.Attribute("op").Value, true); } if (el.Attribute("scope") != null) { Scope = (ConditionScopeType)Enum.Parse(typeof(ConditionScopeType), el.Attribute("scope").Value, true); } }
internal static ComparisonOperation GetOppositeComparisonOperation(ComparisonOperation op) { switch (op) { case ComparisonOperation.Equal: return(ComparisonOperation.NotEqual); case ComparisonOperation.NotEqual: return(ComparisonOperation.Equal); case ComparisonOperation.LessThan: return(ComparisonOperation.GreaterThanOrEqual); case ComparisonOperation.LessThanOrEqual: return(ComparisonOperation.GreaterThan); case ComparisonOperation.GreaterThan: return(ComparisonOperation.LessThanOrEqual); case ComparisonOperation.GreaterThanOrEqual: return(ComparisonOperation.LessThan); default: return(ComparisonOperation.None); } }
private static RequirementOperator GetRequirementOperator(ComparisonOperation comparisonOperation) { switch (comparisonOperation) { case ComparisonOperation.Equal: return(RequirementOperator.Equal); case ComparisonOperation.NotEqual: return(RequirementOperator.NotEqual); case ComparisonOperation.LessThan: return(RequirementOperator.LessThan); case ComparisonOperation.LessThanOrEqual: return(RequirementOperator.LessThanOrEqual); case ComparisonOperation.GreaterThan: return(RequirementOperator.GreaterThan); case ComparisonOperation.GreaterThanOrEqual: return(RequirementOperator.GreaterThanOrEqual); default: return(RequirementOperator.None); } }
internal static string GetOperatorString(ComparisonOperation operation) { switch (operation) { case ComparisonOperation.Equal: return("=="); case ComparisonOperation.NotEqual: return("!="); case ComparisonOperation.LessThan: return("<"); case ComparisonOperation.LessThanOrEqual: return("<="); case ComparisonOperation.GreaterThan: return(">"); case ComparisonOperation.GreaterThanOrEqual: return(">="); default: return(null); } }
public static bool Compare <U>(ComparisonOperation operation, U left, U right) where U : IComparable <U> { // compare them int result = left.CompareTo(right); switch (operation) { case ComparisonOperation.equal: return(result == 0); case ComparisonOperation.notEqual: return(result != 0); case ComparisonOperation.less: return(result < 0); case ComparisonOperation.lessOrEqual: return(result <= 0); case ComparisonOperation.greater: return(result > 0); case ComparisonOperation.greaterOrEqual: return(result >= 0); } return(false); }
private string GetOperationSymbol(ComparisonOperation operation) { switch (operation) { case ComparisonOperation.LessOrEqual: return("<="); case ComparisonOperation.Less: return("<"); case ComparisonOperation.Equal: return("=="); case ComparisonOperation.LargerOrEqual: return(">="); case ComparisonOperation.Larger: return(">"); default: throw new ArgumentOutOfRangeException(operation.ToString() + " is not a supported linear operation."); } }
public bool CalculateIfExcessGuideline(AnalyteGuidelineValue guideline, double?value, ComparisonOperation operation) { var decider = _factory.BuildDecider(guideline.GetType()); var isExcessed = decider.CalculateIfExcessGuideline(guideline, value, operation); return(isExcessed); }
public ConditionIntRange( ConditionField field, ComparisonOperation comparison, int value ) { Field = field; Comparison = comparison; Value = value; }
public ConditionMetadata(string fieldName, ComparisonOperation comparisonOperation, string value) { this.fieldName = fieldName; this.comparisonOperation = comparisonOperation; this.value = value; }
private List<IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex) { IPreprocessingData preprocessingData = Content.FilterLogic.PreprocessingData; IStringConvertibleValue value; if (preprocessingData.VariableHasType<double>(columnIndex)) { value = new DoubleValue(); } else if (preprocessingData.VariableHasType<String>(columnIndex)) { value = new StringValue(); } else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) { value = new DateTimeValue(); } else { throw new ArgumentException("unsupported type"); } value.SetValue(match); var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true); comparisonFilter.ConstraintColumn = columnIndex; return new List<Filter.IFilter>() { comparisonFilter }; }
private Core.ConstraintOperation GetConstraintOperation(ComparisonOperation comparisonOperation) { Core.ConstraintOperation constraintOperation = Core.ConstraintOperation.Equal; switch (comparisonOperation) { case ComparisonOperation.Equal: constraintOperation = Core.ConstraintOperation.Equal; break; case ComparisonOperation.Greater: constraintOperation = Core.ConstraintOperation.Greater; break; case ComparisonOperation.GreaterOrEqual: constraintOperation = Core.ConstraintOperation.GreaterOrEqual; break; case ComparisonOperation.Less: constraintOperation = Core.ConstraintOperation.Less; break; case ComparisonOperation.LessOrEqual: constraintOperation = Core.ConstraintOperation.LessOrEqual; break; case ComparisonOperation.NotEqual: constraintOperation = Core.ConstraintOperation.NotEqual; break; } return constraintOperation; }
public ComparisonExpression(ExpressionBase left, ComparisonOperation operation, ExpressionBase right) : base(left, right, ExpressionType.Comparison) { Operation = operation; }
public IFluentQueryBuilder Where(string fieldName, ComparisonOperation comparisonOperation, string value) { ConditionMetadata condition = new ConditionMetadata(fieldName, comparisonOperation, value); metadata.AddCondition(condition); return this; }
public ConditionPreviousRank( XElement el ) { if( el == null ) throw new ArgumentNullException( "el" ); Rank = RankManager.ParseRank( el.Attribute( "val" ).Value ); Comparison = (ComparisonOperation)Enum.Parse( typeof( ComparisonOperation ), el.Attribute( "op" ).Value, true ); }
public bool CalculateIfExcessGuideline(AnalyteGuidelineValue guideline, double?value, ComparisonOperation operation) { if (!IsSupported(guideline, operation)) { throw new ArgumentException("guideine type or the comparison operation is not supported by the " + this.GetType().Name); } var castedGuideline = (SimpleGuidelineValue)guideline; if (value.HasValue && castedGuideline.GuidelineValue.HasValue) { var operationSymbol = GetOperationSymbol(operation); var expressionString = String.Format("{0} {1} {2}", value.Value, operationSymbol, castedGuideline.GuidelineValue.Value); var expression = new Expression(expressionString); var result = (bool)expression.Evaluate(); return(!result); } return(false); }
void findAndReplaceDialog_FindNextEvent(object sender, EventArgs e) { if (searchIterator == null || currentSearchText != findAndReplaceDialog.GetSearchText() || currentComparisonOperation != findAndReplaceDialog.GetComparisonOperation()) { searchIterator = new FindPreprocessingItemsIterator(FindAll(findAndReplaceDialog.GetSearchText())); currentSearchText = findAndReplaceDialog.GetSearchText(); currentComparisonOperation = findAndReplaceDialog.GetComparisonOperation(); } if (IsOneCellSelected()) { var first = GetSelectedCells().First(); searchIterator.SetStartCell(first.Key, first.Value[0]); } bool moreOccurences = false; currentCell = searchIterator.GetCurrent(); moreOccurences = searchIterator.MoveNext(); if (IsOneCellSelected() && currentCell != null) { var first = GetSelectedCells().First(); if (currentCell.Item1 == first.Key && currentCell.Item2 == first.Value[0]) { if (!moreOccurences) { searchIterator.Reset(); } currentCell = searchIterator.GetCurrent(); moreOccurences = searchIterator.MoveNext(); if (!moreOccurences) { searchIterator.Reset(); } } } dataGridView.ClearSelection(); if (currentCell != null) { dataGridView[currentCell.Item1, currentCell.Item2].Selected = true; dataGridView.CurrentCell = dataGridView[currentCell.Item1, currentCell.Item2]; } }
public ConditionPreviousRank( Rank rank, ComparisonOperation comparison ) { if( rank == null ) throw new ArgumentNullException( "rank" ); if( !Enum.IsDefined( typeof( ComparisonOperation ), comparison ) ) { throw new ArgumentOutOfRangeException( "comparison", "Unknown comparison type" ); } Rank = rank; Comparison = comparison; }
public void Visit(ComparisonOperation node) { throw new NotImplementedException(); }