private void ResetValueEnter() { EditedTag = null; ValueEnterMode = false; SelectedComparator = Comparators.First(); EnteredValue = string.Empty; }
public WBQueryClause(WBColumn column, Comparators comparator, Object value) { Column = column; Comparator = comparator; Value = value; switch (Comparator) { case Comparators.Equals: { break; } case Comparators.NotEquals: { break; } case Comparators.LessThan: { break; } case Comparators.LessThanEquals: { break; } case Comparators.GreaterThan: { break; } case Comparators.GreaterThanEquals: { break; } case Comparators.IsNull: { break; } case Comparators.IsNotNull: { break; } default: throw new NotImplementedException("The selected comparator has not been implemented yet."); } UseDescendants = false; }
public void TestExtractSingleLongTerm() { var nounPhrases = nounPhraseExtractor.Extract("The lovely red ironed rectangular Swiss flag."); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
public void TestExtractSingleShortWord() { var nounPhrases = nounPhraseExtractor.Extract("There is a P."); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
public void ShouldReturnTrueIfYearOldIsGreaterOrEqual18YearOld() { DateTime yerToCompare = DateTime.Now.AddYears(-18); var result = Comparators.IsYearOldIsGreaterOrEqual18YearOld(yerToCompare); Assert.IsTrue(result); }
public Email(string address) { Address = address; if (!Comparators.IsValidEmail(Address)) { AddNotification("E-mail", $"O e-mail {Address} não possui um formato válido"); } }
public Document(string number) { Number = number; if (!Comparators.IsLengthEqualThan(number, Constraints.LengthDocument)) { AddNotification(nameof(Number), $"O número do documento possui {number.Length}. Ele precisa ter o tamanho igual a {Constraints.LengthDocument}"); } }
private void _validations() { if (Comparators.IsLengthLessThan(Street, Constraints.MinimumLengthStreet)) { AddNotification(nameof(Street), $"O rua {Street} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthStreet}"); } else if (Comparators.IsLengthGranThan(Street, Constraints.MaximumLengthStreet)) { AddNotification(nameof(Street), $"O rua {Street} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthStreet}"); } if (Comparators.IsLengthLessThan(Number, Constraints.MinimumLengthNumber)) { AddNotification(nameof(Number), $"O número {Number} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthNumber}"); } else if (Comparators.IsLengthGranThan(Number, Constraints.MaximumLengthNumber)) { AddNotification(nameof(Number), $"O número {Number} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthNumber}"); } if (Comparators.IsLengthLessThan(District, Constraints.MinimumLengthDistrict)) { AddNotification(nameof(District), $"O Distrito {District} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthDistrict}"); } else if (Comparators.IsLengthGranThan(District, Constraints.MaximumLengthDistrict)) { AddNotification(nameof(District), $"O Distrito {District} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthDistrict}"); } if (Comparators.IsLengthLessThan(City, Constraints.MinimumLengthCity)) { AddNotification(nameof(City), $"A Cidade {City} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthCity}"); } else if (Comparators.IsLengthGranThan(City, Constraints.MaximumLengthCity)) { AddNotification(nameof(City), $"A Cidade {City} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthCity}"); } if (Comparators.IsLengthLessThan(Country, Constraints.MinimumLengthCountry)) { AddNotification(nameof(Country), $"O Pais {Country} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthCountry}"); } else if (Comparators.IsLengthGranThan(Country, Constraints.MaximumLengthCountry)) { AddNotification(nameof(Country), $"O Pais {Country} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthCountry}"); } if (Comparators.IsLengthLessThan(ZipCode, Constraints.MinimumLengthZipCode)) { AddNotification(nameof(ZipCode), $"O Código Postal {ZipCode} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthZipCode}"); } else if (Comparators.IsLengthGranThan(ZipCode, Constraints.MaximumLengthZipCode)) { AddNotification(nameof(ZipCode), $"O Código Postal {ZipCode} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthZipCode}"); } }
public void TestExtractSingle() { var nounPhrases = nounPhraseExtractor.Extract("A large red flag fluttered."); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); ISet <string> variants = new HashSet <string>(); variants.Add("large red flag"); expectedNounPhrases.Add("large red flag", variants); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
public Phone(string phoneNumber) { PhoneNumber = phoneNumber; if (Comparators.IsLengthLessThan(phoneNumber, Constraints.MinimumLengthNumber)) { AddNotification(nameof(PhoneNumber), $"O número do telefone {phoneNumber} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthNumber}"); } else if (Comparators.IsLengthGranThan(phoneNumber, Constraints.MaximumLengthNumber)) { AddNotification(nameof(PhoneNumber), $"O número do telefone {phoneNumber} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthNumber}"); } }
internal static ScoreDocComparator GetCachedComparator(IndexReader reader, System.String field, int type, System.Globalization.CultureInfo locale, SortComparatorSource factory) { if (type == SortField.DOC) { return(Lucene.Net.Search.ScoreDocComparator_Fields.INDEXORDER); } if (type == SortField.SCORE) { return(Lucene.Net.Search.ScoreDocComparator_Fields.RELEVANCE); } FieldCacheImpl.Entry entry = (factory != null) ? new FieldCacheImpl.Entry(field, factory) : new FieldCacheImpl.Entry(field, type, locale); return((ScoreDocComparator)Comparators.Get(reader, entry)); }
public void TestExtractMultipleVariantsNumber() { var nounPhrases = nounPhraseExtractor.Extract("There are 12 dogs. A dog can't be seen."); Comparators.PrintDictionaryOfSets(nounPhrases); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); ISet <string> variants = new HashSet <string>(); // NOTE there is a TODO in the code to fix this problem //variants.Add("dogs"); variants.Add("dog"); expectedNounPhrases.Add("dog", variants); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
public void TestExtractMultipleVariants() { var nounPhrases = nounPhraseExtractor.Extract("Dogs are looking at dogs but not at a dog."); Comparators.PrintDictionaryOfSets(nounPhrases); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); ISet <string> variants = new HashSet <string>(); variants.Add("Dogs"); variants.Add("dogs"); variants.Add("dog"); expectedNounPhrases.Add("dog", variants); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
static void Main() { IEqualityComparer cmpId = Comparators.Comparer(typeof(Point), "id"); IEqualityComparer cmpCoords = Comparators.Comparer(typeof(Point), "X", "Y"); IEqualityComparer cmpModule = Comparators.Comparer(typeof(Point), "GetModule"); Point p1 = new Point(54132, 5, 7); Point p2 = new Point(980, 5, 7); Point p3 = new Point(65465, 7, 5); Console.WriteLine(cmpId.Equals(p1, p2)); // false Console.WriteLine(cmpCoords.Equals(p1, p2)); // true Console.WriteLine(cmpCoords.Equals(p2, p3)); // false Console.WriteLine(cmpModule.Equals(p2, p3)); // true }
internal static void Close(IndexReader reader) { lock (Comparators.SyncRoot) { System.Collections.Hashtable readerCache = (System.Collections.Hashtable)Comparators[reader]; if (readerCache != null) { readerCache.Clear(); readerCache = null; } Comparators.Remove(reader); } }
public void TestExtractMultipleVariantsIrregular() { var nounPhrases = nounPhraseExtractor.Extract("Wolves are looking at wolves but not at a wolf."); Comparators.PrintDictionaryOfSets(nounPhrases); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); ISet <string> variants = new HashSet <string>(); // NOTE there is a TODO in the code to fix this problem //variants.Add("Wolves"); //variants.Add("wolves"); variants.Add("wolf"); expectedNounPhrases.Add("wolf", variants); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
/// <summary> /// Gets a functional values in defined y position. /// </summary> /// <param name="start">The start point of the segment.</param> /// <param name="y">The y position.</param> /// <param name="global">True, if y and returned x value is are global space, false, if y and x are related to the start point.</param> /// <param name="tolerance">Tolerance</param> /// <returns>A values related to the y position.</returns> public override double[] GetValueByY(ref Point start, double y, bool global, double tolerance = 0) { Refresh(ref start); if (!global) { y += start.Y; } if (Comparators.InIntervalBoth(start.Y, EndPoint.Y, y, tolerance)) { // y = ax^2 + bx + c // ax^2 + bx + (c - y) = 0; var cc = c - y; var discr = (b * b) - 4 * a * cc; if (discr.IsGreater(0, 1e-5) && !a.IsZero()) { var x1 = (-b + Math.Sqrt(discr)) / (2 * a); var x2 = (-b - Math.Sqrt(discr)) / (2 * a); if (Comparators.InIntervalBoth(start.X, EndPoint.X, x1, tolerance) && Comparators.InIntervalBoth(start.X, EndPoint.X, x2, tolerance)) { return(new double[] { global?x1 : x1 - start.X, global ? x2 : x2 - start.X, }); } else if (Comparators.InIntervalBoth(start.X, EndPoint.X, x1, tolerance)) { return(new double[] { global?x1 : x1 - start.X }); } else if (Comparators.InIntervalBoth(start.X, EndPoint.X, x2, tolerance)) { return(new double[] { global?x2 : x2 - start.X }); } } } return(new double[0]); }
public bool Evaluate() { Object source; if (TestObject.Find(Source) != null) { source = TestObject.Find(Source); } else if (KodiObject.Find(Source) != null) { source = KodiObject.Find(Source); } else if (WeatherObject.Find(Source) != null) { source = WeatherObject.Find(Source); } else if (GenericInfoObject.Find(Source) != null) { source = GenericInfoObject.Find(Source); } else { Console.WriteLine("Source not found"); return(false); } string attribute = source.GetType().GetMethod("AGet" + Attribute).Invoke(source, null).ToString(); Comparators comparator = (Comparators)Enum.Parse(typeof(Comparators), Comparator.ToUpper()); if (comparator.Equals(Comparators.EQUALS)) { return(attribute.Equals(Threshold)); } else if (comparator.Equals(Comparators.MORE)) { try { return(Double.Parse(attribute) > Double.Parse(Threshold)); } catch (Exception) { Console.WriteLine("Cannot cast inputs"); return(false); } } else if (comparator.Equals(Comparators.LESS)) { try { return(Double.Parse(attribute) < Double.Parse(Threshold)); } catch (Exception) { Console.WriteLine("Cannot cast inputs"); return(false); } } else { return(false); } }
public override Rect GetBounds(ref Point start) { var centre = GetCentre(ref start); var angle = GetAngle(ref start); if (Comparators.InIntervalDown(start.X, EndPoint.X, centre.X) && Comparators.InIntervalDown(start.Y, EndPoint.Y, centre.Y)) { if (angle < 180) { return(new Rect(start, EndPoint)); } ////else ////{ //// var r = GetRadius(ref start); //// return new Rect(centre.X - r, centre.Y - r, 2 * r, 2 * r); ////} } var min = new Point(double.PositiveInfinity, double.PositiveInfinity); var max = new Point(double.NegativeInfinity, double.NegativeInfinity); CheckMinMax(ref start, ref min, ref max); Point ep = EndPoint; CheckMinMax(ref ep, ref min, ref max); double a = 5; angle = Math.Abs(angle); if (a < angle) { int numberOfTiles = (int)Math.Ceiling(angle / a); double rel = a / angle; for (int i = 1; i < numberOfTiles; ++i) { var pt = GetPointOnSegment(ref start, i * rel); CheckMinMax(ref pt, ref min, ref max); } } return(new Rect(min, max)); }
/// <summary> /// Gets a functional values in defined y position. /// </summary> /// <param name="start">The start point of the segment.</param> /// <param name="y">The y position.</param> /// <param name="global">True, if y and returned x value is are global space, false, if y and x are related to the start point.</param> /// <param name="tolerance">Tolerance</param> /// <returns>A values related to the y position.</returns> public override double[] GetValueByY(ref Point start, double y, bool global, double tolerance = 0) { if (!global) { y += start.Y; } var bounds = GetBounds(ref start); if (Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, y, tolerance)) { var radius = GetRadius(ref start); var centre = GetCentre(ref start); y -= centre.Y; var x = Math.Sqrt(radius * radius - y * y); var c1 = Comparators.InIntervalBoth(bounds.Left, bounds.Right, centre.X + x, tolerance); var c2 = Comparators.InIntervalBoth(bounds.Left, bounds.Right, centre.X - x, tolerance); if (c1 && c2) { return(new double[] { global?centre.X + x : centre.X + x - start.X, global ? centre.X - x : centre.X - x - start.X, }); } else if (c1) { return(new double[] { global?centre.X + x : centre.X + x - start.X }); } else if (c2) { return(new double[] { global?centre.X - x : centre.X - x - start.X }); } } return(new double[0]); }
/// <summary> /// Gets a functional values in defined x position of the CircularArcSegment. /// </summary> /// <param name="start">The start point of the circular arc segment.</param> /// <param name="x">The x position.</param> /// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param> /// <param name="tolerance">Tolerance</param> /// <returns>A values related to the x position.</returns> public override double[] GetValueByX(ref Point start, double x, bool global, double tolerance = 0) { if (!global) { x += start.X; } var bounds = GetBounds(ref start); if (Comparators.InIntervalBoth(bounds.Left, bounds.Right, x, tolerance)) { var radius = GetRadius(ref start); var centre = GetCentre(ref start); x -= centre.X; var y = Math.Sqrt(radius * radius - x * x); var c1 = Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, centre.Y + y, tolerance); var c2 = Comparators.InIntervalBoth(bounds.Top, bounds.Bottom, centre.Y - y, tolerance); if (c1 && c2) { return(new double[] { global?centre.Y + y : centre.Y + y - start.Y, global ? centre.Y - y : centre.Y - y - start.Y, }); } else if (c1) { return(new double[] { global?centre.Y + y : centre.Y + y - start.Y, }); } else if (c2) { return(new double[] { global?centre.Y - y : centre.Y - y - start.Y, }); } } return(new double[0]); }
public Collaborator( Name name, Document document, Email email, Phone phone, Address address, decimal salary, string projectName, DateTime birthDate, string jobTitle) { Name = name; Document = document; Email = email; Phone = phone; Address = address; IdAddress = address.Id; Salary = salary; ProjectName = projectName; BirthDate = birthDate; JobTitle = jobTitle; CreateDate = DateTime.UtcNow.AddHours(_TIME_ZONE); if (Comparators.IsLengthLessThan(projectName, Constraints.MinimumLengthProjectName)) { AddNotification(nameof(ProjectName), $"O nome do projeto {projectName} é inválido. Ele possui o tamamanho menor do que {Constraints.MinimumLengthProjectName}"); } else if (Comparators.IsLengthGranThan(projectName, Constraints.MaximumLengthProjectName)) { AddNotification(nameof(ProjectName), $"O nome do projeto {projectName} é inválido. Ele possui o tamamanho maior do que {Constraints.MaximumLengthProjectName}"); } if (Comparators.IsLessThan(Salary, Constraints.BaseSalary)) { AddNotification(nameof(Salary), $"O salário {Salary} é inválido. Ele é menor do que o piso salarial {Constraints.BaseSalary}"); } if (!Comparators.IsYearOldIsGreaterOrEqual18YearOld(BirthDate)) { AddNotification(nameof(BirthDate), $"O colaborador não poderá ser cadastrado, pois ele possui menos de 18 anos de idade"); } }
public Name(string firstname, string lastName) { FirstName = firstname; LastName = lastName; if (Comparators.IsLengthGranThan(FirstName, Constraints.MaxLengthFirstName)) { AddNotification(nameof(FirstName), $"O primeiro nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho menor do que {Constraints.MaxLengthFirstName}"); } else if (Comparators.IsLengthLessThan(FirstName, Constraints.MinLengthFirstName)) { AddNotification(nameof(FirstName), $"O primeiro nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho maior do que {Constraints.MinLengthFirstName}"); } if (Comparators.IsLengthGranThan(LastName, Constraints.MaxLengthLastName)) { AddNotification(nameof(LastName), $"O último nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho menor do que {Constraints.MaxLengthFirstName}"); } else if (Comparators.IsLengthLessThan(LastName, Constraints.MinLengthLastName)) { AddNotification(nameof(LastName), $"O último nome possui o tamanho {FirstName.Length}. Ele precisa ter o tamanho maior do que {Constraints.MinLengthFirstName}"); } }
/// <summary> /// Gets a functional values in defined x position of the ParabolicArcSegment. /// </summary> /// <param name="start">The start point of the parabolic arc segment.</param> /// <param name="x">The x position.</param> /// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param> /// <param name="tolerance">Tolerance</param> /// <returns>A values related to the x position.</returns> public override double[] GetValueByX(ref Point start, double x, bool global, double tolerance = 0) { Refresh(ref start); if (!global) { x += start.X; } if (Comparators.InIntervalBoth(start.X, EndPoint.X, x, tolerance)) { // y = ax^2 + bx + c var y = a * x * x + b * x + c; if (!global) { y -= start.Y; } return(new double[] { y }); } return(new double[0]); }
/// <summary> /// Calculates relative position on segment by given x position. /// </summary> /// <param name="start">The start point of the segment.</param> /// <param name="x">The x position.</param> /// <param name="global">True, if x and returned y value is are global space, false, if x and y are related to the start point.</param> /// <returns>The relative position.</returns> public override double[] GetRelativePosition(ref Point start, double x, bool global, double tolerance = 0) { if (!global) { x += start.X; } var radius = GetRadius(ref start); var centre = GetCentre(ref start); if (Comparators.InIntervalBoth(centre.X - radius, centre.X + radius, x, tolerance)) { var xx = x - centre.X; var y = (radius * radius - xx * xx).IsZero() ? 0 : Math.Sqrt(radius * radius - xx * xx); var cc = IsCounterClockwise(ref start); var angle = GetAngle(ref start); Func <Point, Point, double> getAngle = (s, p) => { var u1 = Point.Subtract(s, centre); var u2 = Point.Subtract(p, centre); var a = Vector.AngleBetween(u1, u2) * cc; if (a.IsZero()) { return(0); } return(a < 0 ? 360 + a : a); }; var px = new Point(x, centre.Y + y); var angle1 = getAngle(start, px); px.Y = centre.Y - y; var angle2 = getAngle(start, px); return(new double[] { angle1 / angle, angle2 / angle }); } return(new double[0]); }
public void TestExtractWithConjunction() { var nounPhrases = nounPhraseExtractor.Extract("The red and flat flag."); Comparators.PrintDictionaryOfSets(nounPhrases); Dictionary <string, ISet <string> > expectedNounPhrases = new Dictionary <string, ISet <string> >(); ISet <string> variants = new HashSet <string>(); variants.Add("red"); expectedNounPhrases.Add("red", variants); ISet <string> variants2 = new HashSet <string>(); variants2.Add("flat flag"); expectedNounPhrases.Add("flat flag", variants2); ISet <string> variants3 = new HashSet <string>(); variants3.Add("red and flat flag"); expectedNounPhrases.Add("red and flat flag", variants3); Assert.IsTrue(Comparators.DictionariesOfSetsAreEqual(expectedNounPhrases, nounPhrases)); }
public void ShouldReturntrueWhenEmailIsValid(string email) { bool result = Comparators.IsValidEmail(email); Assert.AreEqual(result, true); }
public void ShouldReturnTrueWhenValueToCompareLengthIsGreaterValueComparator(string valueToCompare, int ValueComparator) { bool result = Comparators.IsLengthGranThan(valueToCompare, ValueComparator); Assert.AreEqual(result, true); }
public void ShouldReturnFalseWhenValueToCompareLengthIsLessValueComparator(string valueToCompare, int ValueComparator) { bool result = Comparators.IsLengthGranThan(valueToCompare, ValueComparator); Assert.AreEqual(result, false); }
public void ShouldReturnTrueWhenValueToCompareIsEqualValueComparator(int valueToCompare, int ValueComparator) { bool result = Comparators.IsEqual(valueToCompare, ValueComparator); Assert.AreEqual(result, true); }