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
+	Addition	a + b	Add the two arguments.
-	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

c) true and true

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

d) false and true

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

a) Empty string ("") and null

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

d) Null and positive integer

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

e) Negative integer and null

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

f) 0 and null

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

g) 0 and false

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

h) Positive integer and true

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.