# # Types of operators

The operators specify what type of actions are performed on arguments (operands) in the formula. HyperFormula supports the operators that are common in spreadsheet software. They are calculated in a specific order which can be altered by the use of parentheses.

HyperFormula supports the following operators:

• Unary operators
• Binary arithmetic operators
• Comparison operators
• Concatenation operator
• Reference operators

## # Unary operators

The unary operators have only one argument (operand). For example, when the unary negation operation is provided with a number, it returns the negative value of that number.

Operator Meaning Example Description
- Unary minus -a Returns the negative of its argument.
+ Unary plus +a Returns the positive of its argument.
% Percent a% Calculate the percent of an argument.

## # Binary arithmetic operators

The binary arithmetic operators enable the computation of basic mathematical operations. They don't have to be wrapped with any functions. This table shows the basic behavior of the binary arithmetic operators:

Operator Meaning Example Description
- Subtraction a - b Subtract the second argument from the first argument.
* Multiplication a * b Multiply the two arguments.
/ Division a / b Divide the first argument by the second argument.
^ Exponentiation a ^ b Raise the first argument by the power of the second argument.

You are probably wondering why the modulo operator is missing. It is supported by the function `MOD` so instead of writing a % b, as you would in a regular mathematical equation, you use a formula like this: =MOD(a, b).

## # Comparison operators

The binary relational operators, when used in a formula, return boolean or logical values. Here are some very general rules:

Operator Meaning Example Description
= Equal to a = b True if a is equal to b.
< Less than a < b True if a is less than b.
> Greater than a > b True if a is greater than b.
<= Less than or equal a <= b True if a is less than or equal to b.
>= Greater than or equal a >= b True if a is greater than or equal to b.
<> Not equal to a <> b True if a is not equal to b.

### # Type coercion

HyperFormula does type coercion and it can have an impact on comparing, adding, or any other operation between values of a different type. The tables represent some operations between different types and their results.

## # Boolean to int coercion, basic arithmetic operations

### # a) true and null

Operation Result
true + null 1
true - null 1
true * null 0
true / null #DIV/0!
true^null 1
+true (unary plus true) true
-true (unary minus true) -1
true% 0.01

### # b) null and true

Operation Result
null + true 1
null - true -1
null * true 0
null / true 0
null ^ true 0
+null (unary plus null) null
-null (unary minus null) 0
null% 0

Operation Result
true + true 2
true - true 0
true * true 1
true / true 1
true ^ true 1

Operation Result
false + true 1
false - true -1
false * true 0
false / true 0
false ^ true 0

### # e) true and false

Operation Result
true + false 1
true - false 1
true * false 0
true / false #DIV/0!
true ^ false 1

### # f) false and false

Operation Result
false + false 0
false - false 0
false * false 0
false / false #DIV/0!
false ^ false 1
+false (unary plus false) false
-false (unary minus false) 0
false% 0

### # g) null and false

Operation Result
null + false 0
null - false 0
null * false 0
null / false #DIV/0!
null ^ false 1

## # Order operations, comparisons

Operation Result
"" > null false
"" < null false
"" >= null true
"" <= null true

### # b) String ("string") and boolean

Operation Result
"string" > false false
"string" < false true
"string" >= false false
"string" <= false true

### # c) Null and false

Operation Result
null > false false
null < false false
null >= false true
null <= false true

Operation Result
null > 1 false
null < 1 true
null >= 1 false
null <= 1 true

Operation Result
-1 > null false
-1 < null true
-1 >= null false
-1 <= null true

Operation Result
0 > null false
0 < null false
0 >= null true
0 <= null true

Operation Result
0 > false false
0 < false true
0 >= false false
0 <= false true
0 = false false

Operation Result
1 > true false
1 < true true
1 >= true false
1 <= true true
1 = true false

## # Comparing strings

By default, HyperFormula is case and accent insensitive. This means it will ignore upper and lower-case letters and accents during the comparison. For example, if you compare `AsTrOnAuT` with `aStroNaut` they will be understood as identical, the same goes for `Préservation` and `Preservation`. It applies to comparison operators only. It can be configured with `accentSensitive` and `caseSensitive` options in the configuration.

Apart from accents and case sensitivity, you can also configure `caseFirst.` This option defines whether upper case or lower case should come first. Additionally the `ignorePunctuation` option specifies whether punctuation should be ignored in string comparison. By default `caseFirst` is set to `'lower'` and `ignorePunctuation` is set to `false`. For more details see the official API reference of HyperFormula.

Here is an example configuration that overwrites default settings:

``````// this part of the configuration shows options
// related to strings only
const options = {
caseSensitive: true,
accentSensitive: true,
caseFirst: 'upper',
ignorePunctuation: true
};
``````

## # Concatenation operator

The concatenation operator is used to combine multiple text strings into a single value.

Operator Meaning Example Description
& Concatenation "a" & "b" Concatenates two arguments
(left and right) into one

## # Reference operators

The reference operators are used to perform calculations of combined ranges.

Operator Meaning Example Description
: (colon) Range operator A1:B1 Makes one reference to multiple cells between the two specified references.
, (comma) Union operator A1:B1,A2:B2 Returns the intersection of multiple ranges.
(space) Intersection operator A1:B1 A2:B2 Finds the intersection of the two ranges.