# Comparing values

There are many times when you need to compare two values to determine whether or not a particular condition exists. When making a comparison, what you are really doing is making a statement that will either be `True</api/language/true>` or `False</api/language/false>`. For example, the statement "My dog is a cat" evaluates to `False</api/language/false>`. However, the statement "My dog weighs more than my cat" may evaluate to `True</api/language/true>`.

| Description              | Symbol | Example  | Result |
|--------------------------|--------|----------|--------|
| Equality                 | =      | 5 = 5    | True   |
| Inequality               | \<\>   | 5 \<\> 5 | False  |
| Greater Than             | \>     | 6 \> 5   | True   |
| Less Than                | \<     | 6 \< 5   | False  |
| Greater Than or Equal To | \>=    | 6 \>= 5  | True   |
| Less Than or Equal To    | \<=    | 6 \<= 5  | False  |

Text and Boolean values can also be used for comparisons. Text comparisons are case-insensitive and alphabetical. This means that "Steve" and "steve" are equal. But "diane" is less than "steve" because "diane" falls alphabetically before "steve". If you need to make case-sensitive or lexicographic comparisons, you use the String.Compare method like this:

``` xojo
Var dog As String = "Dog"
Var cat As String = "Cat"
Var result As Integer

result = dog.Compare(cat, ComparisonOptions.CaseSensitive)
' result = 1, because "Dog" > "Cat"
```

To do a case-sensitive comparison:

``` xojo
Var dog As String = "Dog"
Var cat As String = "aCat"
Var result As Integer

result = dog.Compare(cat, ComparisonOptions.CaseSensitive, Locale.Raw)
' result = -1, because "Dog" < "aCat" when case-sensitive
```

In addition, there is a way to determine whether two floating point numbers are close enough to be considered equal. This is used to account for the imprecision of operations such as floating point division. Use the Double.Equals to do this comparison.

For example, if you are comparing 10000 to a value and specify x=1, then the acceptable values are 10000.000000000002, 10000.0 and 9999.999999999998.

``` xojo
Var d As Double = 10000
Var compareValue As double = 10000.000000000002

If d.Equals(compareValue, 1) Then
  ' take action here...
End If
```

## Logical comparisons

You can test more than one comparison at a time using the And, Or, and Not operators. When passed Boolean values, these operators determine whether the expression is `True</api/language/true>` or `False</api/language/false>`.

### And operator

Use the `And</api/language/operators/bitwise_logical/and>` operator when you need to know if all comparisons evaluate to `True</api/language/true>`. In the example below, if the variable x contains 10 then the expression evaluates to `False</api/language/false>` because 10 is not both greater than 1 and less than 5:

``` xojo
x > 1 And x < 5
```

### Or operator

Use the `Or</api/language/operators/bitwise_logical/or>` operator when you need to know if any of the comparisons evaluate to `True</api/language/true>`. In the example below, if the variable x contains 10 then the expression evaluates to `True</api/language/true>`:

``` xojo
x > 1 Or x < 5
```

This is because 10 is greater than 1. The fact that it is not less than 5 does not matter because you only care if at least one of the comparisons is `True</api/language/true>`.

### Xor operator

Use the `Xor</api/language/operators/bitwise_logical/xor>` operator when you need to know whether any of the comparisons evaluate to `True</api/language/true>`, but not all of them. In the example below, if the variable x contains 10 then the expression evaluates to `True</api/language/true>`.

``` xojo
x > 1 Xor x < 5
```

This is because only one of the comparisons is `True</api/language/true>`. However, if x contains 3 then the above expression returns `False</api/language/false>` because both sub expressions are `True</api/language/true>`.

### Not operator

Use the `Not</api/language/operators/bitwise_logical/not>` operator to reverse the value of a boolean variable. For example, this returns `True</api/language/true>` when x is equal to or greater than 0:

``` xojo
Not x < 0
```

### Truth table

A truth table can help you determine what the results of these various comparisons are.

| Expression 1 | Expression 2 | And   | Or    | Xor   |
|--------------|--------------|-------|-------|-------|
| True         | True         | True  | True  | False |
| True         | False        | False | True  | True  |
| False        | True         | False | True  | True  |
| False        | False        | False | False | False |

## Bitwise comparisons

Sometimes it is helpful, usually in more advanced situations, to be able to compare the actual bits that make up Integers. You can do this using `Bitwise</api/language/bitwise>` class method comparisons, which work by treating the Integer as a binary number. With a binary number, you can then compare each individual bit to get a new set of bits, which results in a new number.

Bitwise comparisons work with the And, Or and Xor operators when they are used with Integers instead of Boolean expressions.

For example, consider the decimal numbers 5 and 3. Written in binary, they are:

- 101 (5)
- 011 (3)

To evaluate 5 Xor 3, you do the comparison on each bit. So for this example:

- 1 Xor 0 = 1
- 0 Xor 1 = 1
- 1 Xor 1 = 0

The new binary value is 110, which is decimal 6.

So this is the final result of the equation: 5 Xor 3 = 6.

The Not operator can also be used to compare Integers. If you pass an integer to Not, it reverses each bit value.

To evaluate Not 5:

- Not 1 = 0
- Not 0 = 1
- Not 1 = 0

The new binary value is 010, which is decimal 2.

### Bitwise tables

Results for And, Or and Xor:

| Bit 1 | Bit 2 | And | Or  | Xor |
|-------|-------|-----|-----|-----|
| 1     | 1     | 1   | 1   | 0   |
| 1     | 0     | 0   | 1   | 1   |
| 0     | 1     | 0   | 1   | 1   |
| 0     | 0     | 0   | 0   | 0   |

Result for Not:

| Bit 1 | Not Bit 1 |
|-------|-----------|
| 1     | 0         |
| 0     | 1         |