public void TestCompareTo() { Assert.IsTrue(MyInt64_3.CompareTo(MyInt64_2) > 0); Assert.IsTrue(MyInt64_2.CompareTo(MyInt64_2) == 0); Assert.IsTrue(MyInt64_1.CompareTo((object)(Int64)(-42)) == 0); Assert.IsTrue(MyInt64_2.CompareTo(MyInt64_3) < 0); try { MyInt64_2.CompareTo((object)(Int16)100); Assert.Fail("Should raise a System.ArgumentException"); } catch (Exception e) { Assert.IsTrue(typeof(ArgumentException) == e.GetType()); } }
static public int MyCustomSort(Transform a, Transform b) { Int64 c1 = Convert.ToInt64(a.name); Int64 c2 = Convert.ToInt64(b.name); return(c2.CompareTo(c1)); }
public Int32 CompareTo(CoordinatePair other) { Int64 product = (Int64)X * Y; Int64 otherProduct = (Int64)other.X * other.Y; return(product.CompareTo(otherProduct)); }
public int CompareTo(object obj) { if (obj is DiscreteTime) { return(m_DiscreteTime.CompareTo(((DiscreteTime)obj).m_DiscreteTime)); } return(1); }
public override int CompareTo(VHDLScalarValue obj) { if (obj is VHDLIntegerValue) { VHDLIntegerValue els = obj as VHDLIntegerValue; return(mValue.CompareTo(els.mValue)); } throw new ArgumentException("Could not cast {0} to VHDLIntegerValue", obj.GetType().Name); }
/// <summary> /// Compares this instance to a specified <see cref="SecsInt64"/> object and returns an integer that indicates their relationship to one another. /// </summary> /// <param name="value">The value.</param> /// <returns></returns> public int CompareTo(SecsInt64 value) { if (value == null) { return(1); } return(_value.CompareTo(value._value)); }
public int CompareTo(object obj) { if (obj is FileGap) { FileGap temp = (FileGap)obj; return(m_start.CompareTo(temp.m_start)); } throw new ArgumentException("object is not a FileGap"); }
public override int CompareTo(VHDLScalarValue obj) { if (obj is VHDLPhysicalValue <T> ) { VHDLPhysicalValue <T> els = obj as VHDLPhysicalValue <T>; return(mValue.CompareTo(els.mValue)); } throw new ArgumentException(string.Format("Could not cast {0} to VHDLPhysicalValue<{1}>", obj.GetType().Name, GetType().Name)); }
public int CompareTo(IndexEntryV1 other) { var keyCmp = Key.CompareTo(other.Key); if (keyCmp != 0) { return(keyCmp); } return(Position.CompareTo(other.Position)); }
Int32 CompareTo(Int64 a, Int64 b, Int64 c, Int64 d) { Int32 cmpVal = a.CompareTo(c); if (cmpVal != 0) { return(cmpVal); } return(b.CompareTo(d)); }
public Int32 CompareTo(Money other) { checkCurrencies(other); var unitCompare = _units.CompareTo(other._units); return(unitCompare == 0 ? _decimalFraction.CompareTo(other._decimalFraction) : unitCompare); }
/// <summary> /// Compares one SmartInt64 to another. /// </summary> /// <remarks> /// This method works the same as the <see cref="int.CompareTo"/> method /// on the Int inttype, with the exception that it /// understands the concept of empty int values. /// </remarks> /// <param name="value">The int to which we are being compared.</param> /// <returns>A value indicating if the comparison int is less than, equal to or greater than this int.</returns> public int CompareTo(SmartInt64 value) { if (this.IsEmpty && value.IsEmpty) { return(0); } else { return(_int.CompareTo(value.Int)); } }
public int Compare(Item x, Item y) { if (x.GetType() == typeof(Folder) || y.GetType() == typeof(Folder)) { return(0); } Int64 temp1 = Int64.Parse(x.StrSize); Int64 temp2 = Int64.Parse(y.StrSize); return(temp2.CompareTo(temp1)); }
public static int CompareTo([JsFakeThis] Int64 _this, object other) { if (other == null) { return(1); } if (!(other is Int64)) { throw new ArgumentException(); } return(_this.CompareTo((Int64)other)); }
private void MethodTests() { featureTest.FailureMessage = "\tFailed Int64 Method Test"; featureTest.Send("Int64 Method Test"); Int64 value1 = 1; Int64 value2 = 2; Int64 value3 = 3; Object obj1 = value1; Object obj2 = value2; Object obj3 = value3; featureTest.AssertTrue(value2.CompareTo(value1) > 0); featureTest.AssertTrue(value2.CompareTo(value3) < 0); featureTest.AssertTrue(value2.CompareTo(value2) == 0); featureTest.AssertTrue(value2.CompareTo(obj1) > 0); featureTest.AssertTrue(value2.CompareTo(obj3) < 0); featureTest.AssertTrue(value2.CompareTo(obj2) == 0); featureTest.AssertTrue(!value2.Equals(value1)); featureTest.AssertTrue(!value2.Equals(value3)); featureTest.AssertTrue(value2.Equals(value2)); featureTest.AssertTrue(!value2.Equals(obj1)); featureTest.AssertTrue(!value2.Equals(obj3)); featureTest.AssertTrue(value2.Equals(obj2)); featureTest.AssertTrue(Int64.Parse("33") == 33); String str = 35.ToString(); featureTest.AssertTrue(str == "35"); Int64 parsed; featureTest.AssertTrue(Int64.TryParse(str, out parsed)); featureTest.AssertTrue(parsed == 35); }
public static void TestCompareTo() { Int64 i = 234; Assert.Equal(0, i.CompareTo((Int64)234)); Assert.True(i.CompareTo(Int64.MinValue) > 0); Assert.True(i.CompareTo((Int64)0) > 0); Assert.True(i.CompareTo((Int64)(-123)) > 0); Assert.True(i.CompareTo((Int64)123) > 0); Assert.True(i.CompareTo((Int64)456) < 0); Assert.True(i.CompareTo(Int64.MaxValue) < 0); }
public int CompareTo(IndexEntry other) { var keyCmp = Stream.CompareTo(other.Stream); if (keyCmp == 0) { keyCmp = Version.CompareTo(other.Version); if (keyCmp != 0) { return(keyCmp); } } if (keyCmp != 0) { return(keyCmp); } return(Position.CompareTo(other.Position)); }
public override int CompareValueTo(int recordNo, object value) { System.Diagnostics.Debug.Assert(0 <= recordNo, "Invalid record"); System.Diagnostics.Debug.Assert(null != value, "null value"); if (NullValue == value) { return(HasValue(recordNo) ? 1 : 0); } Int64 valueNo1 = values[recordNo]; if ((defaultValue == valueNo1) && !HasValue(recordNo)) { return(-1); } return(valueNo1.CompareTo((Int64)value)); //return(valueNo1 < valueNo2 ? -1 : (valueNo1 > valueNo2 ? 1 : 0)); // similar to Int64.CompareTo(Int64) }
private static int SortFun(Int64 numa, Int64 numb, Int64 exclude) { int result; if (numa == exclude || numb == exclude) { if (numa == numb) { result = 0; } else { if (numa == exclude) { result = 1; } else { result = -1; } } } else { if (numa == numb) { result = 0; } else { if (numa.CompareTo(numb) > 0) { result = -1; } else { result = 1; } } } return(result); }
/// <summary> /// Compares this value to another.</summary> /// <param name="value"> /// Other value.</param> /// <returns> /// -1 if this value is less, 0 if equal, 1 if greater</returns> public int CompareTo(LanguageIDTextKey value) { var result = _languageID.CompareTo(value._languageID); return((result == 0) ? _textKey.CompareTo(value._textKey) : result); }
/// <summary> /// A T extension method that check if the value is between inclusively the minValue and maxValue. /// </summary> /// <param name="this">The @this to act on.</param> /// <param name="minValue">The minimum value.</param> /// <param name="maxValue">The maximum value.</param> /// <returns>true if the value is between inclusively the minValue and maxValue, otherwise false.</returns> /// ### /// <typeparam name="T">Generic type parameter.</typeparam> public static bool InRange(this Int64 @this, Int64 minValue, Int64 maxValue) { return(@this.CompareTo(minValue) >= 0 && @this.CompareTo(maxValue) <= 0); }
/// <summary> /// Compares two postcodes (universally) and determines which is greater. /// </summary> /// <param name="APostcodeA"></param> /// <param name="APostcodeB"></param> /// <returns>-1 if APostcodeB is greater, 0 if equal, 1 if APostcodeA is greater</returns> private static int ComparePostcodes(string APostcodeA, string APostcodeB) { int ReturnValue = 0; // // if postcode only contains numbers // int PostcodeLettersA = Regex.Matches(APostcodeA, @"[a-zA-Z]").Count; int PostcodeLettersB = Regex.Matches(APostcodeB, @"[a-zA-Z]").Count; if ((PostcodeLettersA == 0) && (PostcodeLettersB == 0)) { Int64 PostcodeNumberA = Convert.ToInt64(APostcodeA.Replace(" ", "").Replace("-", "")); Int64 PostcodeNumberB = Convert.ToInt64(APostcodeB.Replace(" ", "").Replace("-", "")); return(PostcodeNumberA.CompareTo(PostcodeNumberB)); } // // if postcode contains letters as well // // if postcode contains a space or a hyphen then use recursion to compare both halves int SpaceIndexA = APostcodeA.IndexOf(' '); int SpaceIndexB = APostcodeB.IndexOf(' '); int HyphenIndexA = APostcodeA.IndexOf('-'); int HyphenIndexB = APostcodeB.IndexOf('-'); if ((SpaceIndexA != -1) || (SpaceIndexB != -1)) { if (SpaceIndexA == -1) { SpaceIndexA = APostcodeA.Length; } if (SpaceIndexB == -1) { SpaceIndexB = APostcodeB.Length; } int CompareSubstring = ComparePostcodes(APostcodeA.Substring(0, SpaceIndexA), APostcodeB.Substring(0, SpaceIndexB)); if (CompareSubstring == 0) { if (SpaceIndexA + 1 >= APostcodeA.Length) { return(-1); } else if (SpaceIndexB + 1 >= APostcodeB.Length) { return(1); } return(ComparePostcodes(APostcodeA.Substring(SpaceIndexA + 1), APostcodeB.Substring(SpaceIndexB + 1))); } else { return(CompareSubstring); } } if ((HyphenIndexA != -1) || (HyphenIndexB != -1)) { if (HyphenIndexA == -1) { HyphenIndexA = APostcodeA.Length; } if (HyphenIndexB == -1) { HyphenIndexB = APostcodeB.Length; } int CompareSubstring = ComparePostcodes(APostcodeA.Substring(0, HyphenIndexA), APostcodeB.Substring(0, HyphenIndexB)); if (CompareSubstring == 0) { if (HyphenIndexA + 1 >= APostcodeA.Length) { return(-1); } else if (HyphenIndexB + 1 >= APostcodeB.Length) { return(1); } return(ComparePostcodes(APostcodeA.Substring(HyphenIndexA + 1), APostcodeB.Substring(HyphenIndexB + 1))); } else { return(CompareSubstring); } } // change postcodes to uppercase APostcodeA = APostcodeA.ToUpper(); APostcodeB = APostcodeB.ToUpper(); while (true) { if ((APostcodeA.Length == 0) && (APostcodeB.Length == 0)) { return(0); } else if (APostcodeA.Length == 0) { return(-1); } else if (APostcodeB.Length == 0) { return(1); } int NumberIndexA = APostcodeA.IndexOfAny("0123456789".ToCharArray()); int NumberIndexB = APostcodeB.IndexOfAny("0123456789".ToCharArray()); int NumberLengthA = 0; int NumberLengthB = 0; int LetterIndexA = APostcodeA.IndexOfAny("ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray()); int LetterIndexB = APostcodeB.IndexOfAny("ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray()); int LetterLengthA = 0; int LetterLengthB = 0; // if one postcode starts with a number but the other starts with a letter if ((NumberIndexA == 0) && (NumberIndexB != 0)) { return(-1); } else if ((NumberIndexA != 0) && (NumberIndexB == 0)) { return(1); } // if both postcodes begin with a number if ((NumberIndexA == 0) && (NumberIndexB == 0)) { // find character indexs and lengths if (LetterIndexA == -1) { NumberLengthA = APostcodeA.Length; } else { NumberLengthA = LetterIndexA; } if (LetterIndexB == -1) { NumberLengthB = APostcodeA.Length; } else { NumberLengthB = LetterIndexB; } // compare the beginning number ReturnValue = Convert.ToInt64(APostcodeA.Substring(0, NumberLengthA)).CompareTo(Convert.ToInt64(APostcodeB.Substring(0, NumberLengthB))); if (ReturnValue != 0) { return(ReturnValue); } // if numbers are equal... for (int i = LetterIndexA; i < APostcodeA.Length; i++) { if (char.IsNumber(APostcodeA[i])) { break; } LetterLengthA++; } for (int i = LetterIndexB; i < APostcodeB.Length; i++) { if (char.IsNumber(APostcodeB[i])) { break; } LetterLengthB++; } // compare letters ReturnValue = APostcodeA.Substring(LetterIndexA, LetterLengthA).CompareTo(APostcodeB.Substring(LetterIndexB, LetterLengthB)); if (ReturnValue != 0) { return(ReturnValue); } // if letters are equal... APostcodeA = APostcodeA.Substring(NumberLengthA + LetterLengthA); APostcodeB = APostcodeB.Substring(NumberLengthB + LetterLengthB); } // if bothe postcodes start with a letter else if ((LetterIndexA == 0) && (LetterIndexB == 0)) { // find character indexs and lengths if (NumberIndexA == -1) { LetterLengthA = APostcodeA.Length; } else { LetterLengthA = NumberIndexA; } if (NumberIndexB == -1) { LetterLengthB = APostcodeB.Length; } else { LetterLengthB = NumberIndexB; } // compare the beginning letters ReturnValue = APostcodeA.Substring(0, LetterLengthA).CompareTo(APostcodeB.Substring(0, LetterLengthB)); if (ReturnValue != 0) { return(ReturnValue); } // if letters are equal... for (int i = NumberIndexA; i < APostcodeA.Length; i++) { if (!char.IsNumber(APostcodeA[i])) { break; } NumberLengthA++; } for (int i = NumberIndexB; i < APostcodeB.Length; i++) { if (!char.IsNumber(APostcodeB[i])) { break; } NumberLengthB++; } // compare number ReturnValue = Convert.ToInt64(APostcodeA.Substring(NumberIndexA, NumberLengthA)).CompareTo(Convert.ToInt64(APostcodeB.Substring(NumberIndexB, NumberLengthB))); if (ReturnValue != 0) { return(ReturnValue); } // if numbers are equal... APostcodeA = APostcodeA.Substring(NumberLengthA + LetterLengthA); APostcodeB = APostcodeB.Substring(NumberLengthB + LetterLengthB); } } }
/// <summary> /// A T extension method that check if the value is between (exclusif) the minValue and maxValue. /// </summary> /// <param name="this">The @this to act on.</param> /// <param name="minValue">The minimum value.</param> /// <param name="maxValue">The maximum value.</param> /// <returns>true if the value is between the minValue and maxValue, otherwise false.</returns> /// ### /// <typeparam name="T">Generic type parameter.</typeparam> public static bool Between(this Int64 @this, Int64 minValue, Int64 maxValue) { return(minValue.CompareTo(@this) == -1 && @this.CompareTo(maxValue) == -1); }
/// <summary>比较</summary> /// <param name="other"></param> /// <returns></returns> public Int32 CompareTo(Block other) => Position.CompareTo(other.Position);
public static Int64 of(Int64 left, Int64 right) { return(left.CompareTo(right) < 0 ? right : left); }
public Int32 CompareTo(CastRoom other) => roomName.CompareTo(other.roomName).notZero() ?? roomId.CompareTo(other.roomId);
private static int DateTimeComparer(Int64 a, Int64 b) { return(b.CompareTo(a)); }
public static void Main() { string nl = Environment.NewLine; string msg = "{0}The following is the result of using the generic and non-generic{0}" + "versions of the CompareTo method for several base types:{0}"; DateTime now = DateTime.Now; // Time span = 11 days, 22 hours, 33 minutes, 44 seconds TimeSpan tsX = new TimeSpan(11, 22, 33, 44); // Version = 1.2.333.4 Version versX = new Version("1.2.333.4"); // Guid = CA761232-ED42-11CE-BACD-00AA0057B223 Guid guidX = new Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}"); Boolean a1 = true, a2 = true; Byte b1 = 1, b2 = 1; Int16 c1 = -2, c2 = 2; Int32 d1 = 3, d2 = 3; Int64 e1 = 4, e2 = -4; Decimal f1 = -5.5m, f2 = 5.5m; Single g1 = 6.6f, g2 = 6.6f; Double h1 = 7.7d, h2 = -7.7d; Char i1 = 'A', i2 = 'A'; String j1 = "abc", j2 = "abc"; DateTime k1 = now, k2 = now; TimeSpan l1 = tsX, l2 = tsX; Version m1 = versX, m2 = new Version("2.0"); Guid n1 = guidX, n2 = guidX; // The following types are not CLS-compliant. SByte w1 = 8, w2 = 8; UInt16 x1 = 9, x2 = 9; UInt32 y1 = 10, y2 = 10; UInt64 z1 = 11, z2 = 11; // Console.WriteLine(msg, nl); try { // The second and third Show method call parameters are automatically boxed because // the second and third Show method declaration arguments expect type Object. Show("Boolean: ", a1, a2, a1.CompareTo(a2), a1.CompareTo((Object)a2)); Show("Byte: ", b1, b2, b1.CompareTo(b2), b1.CompareTo((Object)b2)); Show("Int16: ", c1, c2, c1.CompareTo(c2), c1.CompareTo((Object)c2)); Show("Int32: ", d1, d2, d1.CompareTo(d2), d1.CompareTo((Object)d2)); Show("Int64: ", e1, e2, e1.CompareTo(e2), e1.CompareTo((Object)e2)); Show("Decimal: ", f1, f2, f1.CompareTo(f2), f1.CompareTo((Object)f2)); Show("Single: ", g1, g2, g1.CompareTo(g2), g1.CompareTo((Object)g2)); Show("Double: ", h1, h2, h1.CompareTo(h2), h1.CompareTo((Object)h2)); Show("Char: ", i1, i2, i1.CompareTo(i2), i1.CompareTo((Object)i2)); Show("String: ", j1, j2, j1.CompareTo(j2), j1.CompareTo((Object)j2)); Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo((Object)k2)); Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo((Object)l2)); Show("Version: ", m1, m2, m1.CompareTo(m2), m1.CompareTo((Object)m2)); Show("Guid: ", n1, n2, n1.CompareTo(n2), n1.CompareTo((Object)n2)); // Console.WriteLine("{0}The following types are not CLS-compliant:", nl); Show("SByte: ", w1, w2, w1.CompareTo(w2), w1.CompareTo((Object)w2)); Show("UInt16: ", x1, x2, x1.CompareTo(x2), x1.CompareTo((Object)x2)); Show("UInt32: ", y1, y2, y1.CompareTo(y2), y1.CompareTo((Object)y2)); Show("UInt64: ", z1, z2, z1.CompareTo(z2), z1.CompareTo((Object)z2)); } catch (Exception e) { Console.WriteLine(e); } }
public virtual bool runTest() { Console.Error.WriteLine("Co1118CompareTo runTest() started."); String strLoc = "Loc_000oo"; StringBuilder sblMsg = new StringBuilder(99); int iCountErrors = 0; int iCountTestcases = 0; long lo8b = -12; Int64 int8a = 55; try { LABEL_860_GENERAL: do { strLoc = "Loc_120au"; strLoc = "Loc_121eu"; lo8b = -12; lo8b = int8a.CompareTo((Int64)66); ++iCountTestcases; if (!(lo8b < 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_337uf! lo8b==" + lo8b); } strLoc = "Loc_122fu"; lo8b = -12; lo8b = int8a.CompareTo(55L); ++iCountTestcases; if (!(lo8b == -0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_248ak! lo8b==" + lo8b); } strLoc = "Loc_123gu"; lo8b = -12; lo8b = int8a.CompareTo((Int64)(-77)); ++iCountTestcases; if (!(lo8b > 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_411wq! lo8b==" + lo8b); } strLoc = "Loc_201ax"; lo8b = -12; lo8b = int8a.CompareTo(null); ++iCountTestcases; if (!(lo8b > 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_713tw! lo8b==" + lo8b); } strLoc = "Loc_202bx"; lo8b = -12; lo8b = int8a.CompareTo((Type)null); ++iCountTestcases; if (!(lo8b > 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_714rw! lo8b==" + lo8b); } strLoc = "Loc_301zv"; lo8b = -12; lo8b = (Int64.MinValue).CompareTo((Int64.MinValue + 1)); ++iCountTestcases; if (!(lo8b < 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_958je! lo8b==" + lo8b); } strLoc = "Loc_303uv"; Console.Error.WriteLine("Info Inf_774dx. (Integer8.MinValue-Integer8.MaxValue)==" + unchecked (Int64.MinValue - Int64.MaxValue)); strLoc = "Loc_302yv"; lo8b = -12; lo8b = (Int64.MinValue).CompareTo(Int64.MaxValue); ++iCountTestcases; if (!(lo8b < 0)) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_842sc! lo8b==" + lo8b); } strLoc = "Loc_400hh"; strLoc = "Loc_401ih"; try { ++iCountTestcases; lo8b = -12; lo8b = int8a.CompareTo((Int16)22); ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_522yh! lo8b==" + lo8b); } catch (ArgumentException argexc) {} catch (Exception excep1) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_636pi! excep1==" + excep1); } strLoc = "Loc_402jh"; try { ++iCountTestcases; lo8b = -12; lo8b = int8a.CompareTo(22); ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_452yh! lo8b==" + lo8b); } catch (ArgumentException argexc) {} catch (Exception excep1) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_796pi! excep1==" + excep1); } } while (false); } catch (Exception exc_general) { ++iCountErrors; Console.Error.WriteLine("POINTTOBREAK: Error Err_343un! (Co1118CompareTo) exc_general==" + exc_general); Console.Error.WriteLine("EXTENDEDINFO: (Err_343un) strLoc==" + strLoc); } if (iCountErrors == 0) { Console.Error.WriteLine("paSs. Integer8\\Co1118CompareTo.cs iCountTestcases==" + iCountTestcases); return(true); } else { Console.Error.WriteLine("FAiL! Integer8\\Co1118CompareTo.cs iCountErrors==" + iCountErrors); return(false); } }
private static void Compare_Int64(Int64 a, Int64 b) => AssertEquals(a.CompareTo(b), Comparer <Int64> .Default.Compare(a, b));