equality

Properly testing two floating-point numbers for equality is something that a lot of people, including me, don't fully understand. Today, however, I thought about how some standard containers define equality in terms of operator< . I always see people with problems surrounding equality, but never with the other relational comparisons. There are even silent versions of them to use, which include everything except for equality and inequality. Assuming operator< works "properly", unlike operator== , why couldn't we do this: bool floateq(float a, float b) { //check NaN return !(a < b) && !(b < a);

As Which equals operator (== vs ===) should be used in JavaScript comparisons? indicates they are basically identical except ' === ' also ensures type equality and hence ' == ' might perform type conversion. In Douglas Crockford's JavaScript: The Good Parts , it is advised to always avoid ' == '. However, I'm wondering what the original thought of designing two set of equality operators was. Have you seen any situation that using ' == ' actually is more suitable than using ' === '? Consider a situation when you compare numbers or strings: if (4 === 4) { // true } but if (4 == "4") { // true }

I have created two enums and I know they are not the same but still I think it makes sense they would be equal since their string representation as well as their numeral representation are equal (and even the same...). In other words : I would like the first test to pass and the second one to fail. In reality however, they both fail. So : when are two enums in C# equal? Or is there anyway to define the equals operator in C#? Thanks! public enum enumA {one, two} public enum enumB {one, two} [Test] public void PreTest() { Assert.AreEqual(enumA.one,enumB.one); Assert.AreSame(enumA.one, enumB.one)

What is the difference between the evaluation of == and Equals in C#? For Ex, if(x==x++)//Always returns true but if(x.Equals(x++))//Always returns false Edited: int x=0; int y=0; if(x.Equals(y++))// Returns True According to the specification, this is expected behavior. The behavior of the first is governed by section 7.3 of the spec: Operands in an expression are evaluated from left to right. For example, in F(i) + G(i++) * H(i) , method F is called using the old value of i, then method G is called with the old value of i, and, finally, method H is called with the new value of i. This is

I've recently been reading about the behavior of GStringImpl s vs String s when used in collections in Groovy. I understand that the reason this evaluates to false... "${'test'}".equals("test") == false is due to the symmetry requirement of the .equals() contract, however I was wondering if there was a reason the GStringImpl couldn't just be evaluated to a String immediately. So when I do something like this... "${'someString'}" I don't get a GStringImpl , I just get a plain Java String back, which I can immediately use as the key in a map, for example. I know there are some workarounds, like

From their brief summary descriptions, it sounds like the string comparison rules StringComparison.Ordinal and StringComparison.InvariantCulture are meant to differ in how they do sorting of strings. Is that all ? i.e., does that mean we can use either string comparison rule when doing an equality comparison? string.Equals(a, b, StringComparison....) And for extra credit: does it make a difference to the answer if we compare OrdinalIgnoreCase and InvariantCultureIgnoreCase ? How? Please provide supporting argument and/or references. It does matter, for example - there is a thing called

I have a piece of code which I need to understand: public static void main(String[] args) { Character c = new Character('a'); Character cy = new Character('a'); char cx = 'a'; System.out.println(c == cx); System.out.println(cx == cy); System.out.println(c == cy); } Output: true true false I am unable to understand why only the third statement is failing. EDIT: This question is different to the .equals vs == question as this about primitive versus object comparison. c and cy refer to different instances of the Character class (each time you invoke a constructor, you create a new instance), so

This question already has an answer here: When are Java Strings interned? 2 answers I am really confused with how string interning works in Java. When I write: String a = "ABC"; String b = "ABC"; if (a==b) System.out.println("Equal"); Does the compiler store the string literal "ABC" into the string constant pool at compile time? That sounds illogical, because I thought the string constant pool was created by the JVM at runtime, and I don't see how that is possible if it is done at compile time since the Java compiler does not even invoke the JVM. If it is not done at compile time and it is