SUMIF function

SUMIF(array, condition) SUMIF(array; condition)

array — { Number }

The array containing the numbers to add together.

condition

A text string specifying the condition, like ">1"">1", a number which array elements must be equal to or a formula fragment specifying the condition.

If a text string is given, the following operators are supported: < (less than), <= (less than or equal to), > (greater than), >= (greater than or equal to), = and == (equality), <> and != (inequality). "" means "only blank values," "<>" and "!=" mean "only non-blank values."

If a formula fragment is given, it must return a logical value (TRUE or FALSE) specifying whether the element under consideration should be included. To do its work, it has access to the values Element (the array element currently being tested), Index (the numeric position of the array element currently being tested, starting at 1) and Source, the source array.

Returns — Number or { Number }

The sum of the array elements that satisfy a condition.

Returns the sum of the array elements that satisfy a condition (adding them together). SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1") returns 5 (2 + 32 + 3) and not 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the ">1"">1" parameter.

Use & to reference values that reside elsewhere. This formula only considers those array elements which are greater than the value of Field1:

SUMIF({ 1, 2, 3 }, ">" & Field1)SUMIF({ 1; 2; 3 }; ">" & Field1)

SUMIF can use separate arrays, of equal size, for determining which elements to consider and for determining which numbers to add together. This version is described further down. Use SUMIFS to use multiple conditions (or use SUMIF with a formula fragment and &&, described below).

Writing conditions

SUMIF supports the following operators: < (less than), <= (less than or equal to), > (greater than), >= (greater than or equal to), = and == (equality), <> and != (inequality).

If the second parameter is set to "", only blank values are considered. If it is set to "<>" or "!=", all non-blank values are considered.

If the operator is left out, "=" is assumed. As a result, these formulas are equivalent:

SUMIF({ 1, 2, 3 }, "=2")SUMIF({ 1; 2; 3 }; "=2")
SUMIF({ 1, 2, 3 }, "2")SUMIF({ 1; 2; 3 }; "2")
SUMIF({ 1, 2, 3 }, 2)SUMIF({ 1; 2; 3 }; 2)

The language settings of the app are taken into account when parsing numbers that are part of the condition text string, meaning that an app configured to use German should use a decimal comma (",") as a decimal separator and an app configured to use Australian English should use a decimal point ("."). Thousands separators should not be used and negative numbers should use a leading minus sign ("-").

Specifying the condition using a formula fragment

The second parameter can also be a formula fragment. These formulas are equivalent, with the second one using a formula fragment:

SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1")
SUMIF({ 1, 2, 3 }, Element > 1)SUMIF({ 1; 2; 3 }; Element > 1)

Using a formula fragment gives you access to the full power of the formula language. Consider this formula:

SUMIF({ 1, 2, 3 }, (Element > 1) && ISODD(Element))SUMIF({ 1; 2; 3 }; (Element > 1) && ISODD(Element))

The formula above returns 3, because only array elements are considered which are greater than 1 and are odd numbers, which disqualifies 1 and 2, leaving only 3.

&& means logical "and," || means logical "or" and ! means logical negation.

This formula returns 6 (1 + 2 + 31 + 2 + 3), as 1, 2 and 3 are all considered:

SUMIF({ 1, 2, 3 }, (Element > 1) || ISODD(Element))SUMIF({ 1; 2; 3 }; (Element > 1) || ISODD(Element))

1, 2 and 3 are all considered due to the || operator, which causes all array elements to be considered which are either greater than 1 or are odd.

This formula returns 2, as only 2 is both greater than 1 and is "not odd" (even):

SUMIF({ 1, 2, 3 }, (Element > 1) && !ISODD(Element))SUMIF({ 1; 2; 3 }; (Element > 1) && !ISODD(Element))

! in !ISODD(Element)!ISODD(Element) negates the value returned from ISODD, causing TRUE to become FALSE and vice versa.

The formula fragment is run once for every array element to be tested, and is expected to return TRUE if the element should be considered, and FALSE otherwise. To do its work, it has access to the values Element (the array element currently being tested), Index (the numeric position of the array element currently being tested, starting at 1) and Source, the source array.

Using FILTER, SUM and REDUCE instead of SUMIF

The work SUMIF performs can be divided into two parts: filtering out unwanted array elements and then returning the sum of the array elements which made the cut. As such, these formulas are equivalent:

SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1")
SUM(FILTER({ 1, 2, 3 }, Element > 1))SUM(FILTER({ 1; 2; 3 }; Element > 1))

The version using FILTER provides more flexibility, as the final step (adding the remaining numbers together through SUM) can be replaced by another function (like PRODUCT, which multiplies the remaining numbers together), independent of the filtering logic.

For even more flexibility, consider replacing SUM with REDUCE. Refer to the example below for more information.

Examples

SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1")

Returns 5 (2 + 32 + 3). It does not return 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the ">1"">1" parameter.

SUMIF(Field1:Field10, ">1")SUMIF(Field1:Field10; ">1")

Returns the sum of all fields in the Field1:Field10Field1:Field10 range, where only fields whose values are greater than 1 are considered.

SUMIF({ 1, 2, 3 }, ">" & Field1)SUMIF({ 1; 2; 3 }; ">" & Field1)

Determines which of the numbers of the { 1, 2, 3 }{ 1; 2; 3 } array are greater than the value of Field1 and returns the sum of those numbers. If Field1.ValueField1,Value is 1, then 5 is returned (2 + 32 + 3).

SUMIF({ 1, 2, 3 }, "=2")SUMIF({ 1; 2; 3 }; "=2")

Returns 2, as only 2 in the array { 1, 2, 3 }{ 1; 2; 3 } satisfies the "=2""=2" condition.

SUMIF({ 1, 2, 3 }, "2")SUMIF({ 1; 2; 3 }; "2")

Returns 2, as only 2 in the array { 1, 2, 3 }{ 1; 2; 3 } satisfies the "2""2" condition. Equality is implied when no operator is specified.

SUMIF({ 1, 2, 3 }, 2)SUMIF({ 1; 2; 3 }; 2)

Returns 2, as only 2 in the array { 1, 2, 3 }{ 1; 2; 3 } satisfies the 22 condition. When a plain value is given as the second parameter, equality is implied. If only values equal to another value should be considered, using a plain value instead of a value enclosed in a text string is preferable, as errors can be detected at an earlier stage.

SUMIF({ 1.1, 1.2, 1.3 }, ">1.1")SUMIF({ 1,1; 1,2; 1,3 }; ">1.1")

Returns 2.5 (1.2 + 1.31,2 + 1,3). It does not return 3.6 (1.1 + 1.2 + 1.31,1 + 1,2 + 1,3), as only 1.2 and 1.3 are greater than 1.1, as specified by the ">1.1"">1.1" parameter. A decimal separator appropriate for the language of the app should be used. If that language is French, for instance, a decimal comma should be used ("1,1" instead of "1.1").

SUMIF({ 1, 2, 3 }, Element > 1)SUMIF({ 1; 2; 3 }; Element > 1)

Returns 5 (2 + 32 + 3). It does not return 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the Element > 1Element > 1 parameter. This example uses a formula fragment instead of a text string. It is invoked once for every array element considered, and is expected to return TRUE if the value should be considered and FALSE otherwise. To do its work, it has access to the Element value, which is the value under consideration.

SUMIF({ 1, 2, 3 }, (Element > 1) && ISODD(Element))SUMIF({ 1; 2; 3 }; (Element > 1) && ISODD(Element))

Returns 3, as only 3 is both greater than 1 and is an odd number. Formula fragments have access to the full power of the formula language, enabling complex conditions. && means logical "and," || means logical "or" and ! means logical negation.

SUM(FILTER({ 1, 2, 3 }, Element > 1))SUM(FILTER({ 1; 2; 3 }; Element > 1))

Returns 5 (2 + 32 + 3). It does not return 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the Element > 1Element > 1 parameter. FILTER first removes array elements which are not greater than 1 (specifically, the element 1). Finally, SUM adds the remaining numbers (2 and 3) together and returns the result.

REDUCE(FILTER({ 1, 2, 3 }, Element > 1), (A, V) -> A + V, 0)REDUCE(FILTER({ 1; 2; 3 }; Element > 1); (A; V) -> A + V; 0)

Returns 5 (2 + 32 + 3). It does not return 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the Element > 1Element > 1 parameter to FILTER. REDUCE is a more flexible alternative to functions like SUM. Refer to its documentation to learn how it works.

SUMIF(conditionArray, condition, targetArray) SUMIF(conditionArray; condition; targetArray)

conditionArray — { Number }, { Logical }, { Text } or { Color }

The array containing the values to test. Only the numbers of the second array, targetArray, which correspond to the elements of this array which satisfy the condition, are used in the final calculation. Two elements are said to correspond to each other if they are in the same position in their respective arrays.

condition

A text string specifying the condition, like ">1"">1", a number which array elements must be equal to or a formula fragment specifying the condition.

If a text string is given, the following operators are supported: < (less than), <= (less than or equal to), > (greater than), >= (greater than or equal to), = (equality, case-insensitive for text), == (equality, case-sensitive for text), <> (inequality, case-insensitive for text) and != (inequality, case-sensitive for text). "" means "only blank values," "<>" and "!=" mean "only non-blank values."

If a formula fragment is given, it must return a logical value (TRUE or FALSE) specifying whether the element under consideration should be included. To do its work, it has access to the values Element (the array element currently being tested), Index (the numeric position of the array element currently being tested, starting at 1) and Source, the first array.

targetArray — { Number }

The array containing the numbers to add together. Only numbers corresponding to elements of the first array which satisfy the given condition are considered. Two elements are said to correspond to each other if they are in the same position in their respective arrays.

Returns — Number or { Number }

The sum of all array elements which satisfy a condition.

Returns the sum of all array elements which satisfy a condition (adding them together). SUMIF({ 1, 2, 3 }, ">1", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">1"; { 10; 20; 30 }) returns 50 (20 + 3020 + 30) and not 60 (10 + 20 + 3010 + 20 + 30), as only 2 and 3 of the first array are greater than 1, as specified by the ">1"">1" parameter.

Use & to reference values that reside elsewhere. This formula only considers those elements of the second array which are greater than the value of Field1:

SUMIF({ 1, 2, 3 }, ">" & Field1, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">" & Field1; { 10; 20; 30 })

SUMIF can use the same array for determining which elements to consider and for determining which numbers to add together. This version is described further up. Use SUMIFS to use multiple conditions (or use SUMIF with a formula fragment and &&, described below).

Beyond numbers

The first array does not need to be a number array. This formula returns 30 (10 + 2010 + 20), as only 10 and 20 correspond to "Eve" in the first array:

SUMIF({ "Eve", "Eve", "Bill" }, "Eve", { 10, 20, 30 })SUMIF({ "Eve"; "Eve"; "Bill" }; "Eve"; { 10; 20; 30 })

Writing conditions

SUMIF supports the following operators: < (less than), <= (less than or equal to), > (greater than), >= (greater than or equal to), = (equality, case-insensitive for text), == (equality, case-sensitive for text), <> (inequality, case-insensitive for text) and != (inequality, case-sensitive for text).

If the second parameter is set to "", only the blank values of the second array are considered. If it is set to "<>" or "!=", all non-blank values are considered.

If the operator is left out, "=" is assumed. As a result, these formulas are equivalent:

SUMIF({ 1, 2, 3 }, "=20", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; "=20"; { 10; 20; 30 })
SUMIF({ 1, 2, 3 }, "20", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; "20"; { 10; 20; 30 })
SUMIF({ 1, 2, 3 }, 20, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; 20; { 10; 20; 30 })

The language settings of the app are taken into account when parsing numbers that are part of the condition text string, meaning that an app configured to use German should use a decimal comma (",") as a decimal separator and an app configured to use Australian English should use a decimal point ("."). Thousands separators should not be used and negative numbers should use a leading minus sign ("-").

Specifying the condition using a formula fragment

The second parameter can also be a formula fragment. These formulas are equivalent, with the second one using a formula fragment:

SUMIF({ 1, 2, 3 }, ">1", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">1"; { 10; 20; 30 })
SUMIF({ 1, 2, 3 }, Element > 1, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; Element > 1; { 10; 20; 30 })

Using a formula fragment gives you access to the full power of the formula language. Consider this formula:

SUMIF({ 1, 2, 3 }, (Element > 1) && ISODD(Element), { 10, 20, 30 })SUMIF({ 1; 2; 3 }; (Element > 1) && ISODD(Element); { 10; 20; 30 })

The formula above returns 30, because only array elements are considered which are greater than 1 and are odd numbers, which disqualifies 1 and 2, leaving only 3 (corresponding to 30 in the second array).

&& means logical "and," || means logical "or" and ! means logical negation.

This formula returns 60 (10 + 20 + 3010 + 20 + 30), as 1, 2 and 3 are all considered:

SUMIF({ 1, 2, 3 }, (Element > 1) || ISODD(Element), { 10, 20, 30 })SUMIF({ 1; 2; 3 }; (Element > 1) || ISODD(Element); { 10; 20; 30 })

1, 2 and 3 are all considered due to the || operator, which causes all array elements to be considered which are either greater than 1 or are odd (1, 2 and 3 correspond to 10, 20 and 30 in the second array).

This formula returns 20, as only 2 is both greater than 1 and is "not odd" (even):

SUMIF({ 1, 2, 3 }, (Element > 1) && !ISODD(Element), { 10, 20, 30 })SUMIF({ 1; 2; 3 }; (Element > 1) && !ISODD(Element); { 10; 20; 30 })

! in !ISODD(Element)!ISODD(Element) negates the value returned from ISODD, causing TRUE to become FALSE and vice versa.

The formula fragment is run once for every array element to be tested, and is expected to return TRUE if the element should be considered, and FALSE otherwise. To do its work, it has access to the values Element (the element of the first array currently being tested), Index (the numeric position of the array element currently being tested, starting at 1) and Source, the first array.

Using wildcards in the condition to match text flexibly

When the first array contains text strings, the condition can use special characters to match multiple text strings. This formula returns 110 (10 + 10010 + 100), because both "car" and "cat" match the wildcard "ca?":

SUMIF({ "car", "cat" }, "ca?", { 10, 100 })SUMIF({ "car"; "cat" }; "ca?"; { 10; 100 })

? matches any character. "ca?" matches not only "car" and "cat", but also "cab", "can" and "cap". However, it does not match "card", because ? matches exactly one character, nor does it match "ca".

* matches no character, a single character, or multiple characters. As such, "ca*" matches everything that "ca?" matches, but also "card", "ca" and "Canada" (matching is case-insensitive).

? and * can be combined in the same pattern. Colo*r ad*s are great? matches both "Color ads are great!" and "Colour adverts are great?".

Sometimes, the special characters ? and * need to be included as-is, and not have special meaning. To achieve that, precede each special character with a tilde ("~"). This formula returns 100, because only "ca*" in the first array matches "ca~*":

SUMIF({ "cat", "ca*" }, "ca~*", { 10, 100 })SUMIF({ "cat"; "ca*" }; "ca~*"; { 10; 100 })

In other words, to search for a verbatim "*" character, write "~*". To search for a verbatim "?" character, write "~?". Finally, to search for a verbatim "~" character, write "~~".

Regular expressions are much more powerful than wildcards, but are also harder to learn. Use REGEXMATCH in a formula fragment to use regular expressions with SUMIF.

This formula returns 10, because only "123" matches the "\d\d\d" regular expression (which only accepts exactly three numbers):

SUMIF({ "123", "ab3" }, REGEXMATCH(Element, "\d\d\d"), { 10, 100 })SUMIF({ "123"; "ab3" }; REGEXMATCH(Element; "\d\d\d"); { 10; 100 })

Refer to the documentation of REGEXMATCH for more information.

Using FILTER, SUM and REDUCE instead of SUMIF

The work SUMIF performs can be divided into two parts: filtering out the unwanted elements from the first array and then returning the sum of the elements of the second array which correspond to the ones in the first array which made the cut. As such, these formulas are equivalent:

SUMIF({ 1, 2, 3 }, ">1", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">1"; { 10; 20; 30 })
SUM(FILTER({ 10, 20, 30 }, { 1, 2, 3 } > 1))SUM(FILTER({ 10; 20; 30 }; { 1; 2; 3 } > 1))

The version using FILTER provides more flexibility, as the final step (adding the remaining numbers together through SUM) can be replaced by another function (like PRODUCT, which multiplies the remaining numbers together), independent of the filtering logic.

For even more flexibility, consider replacing SUM with REDUCE. Refer to the example below for more information.

Examples

SUMIF({ 1, 2, 3 }, ">1", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">1"; { 10; 20; 30 })

Returns 50 (20 + 3020 + 30). It does not return 60 (10 + 20 + 3010 + 20 + 30), as only 2 and 3 of the first array are greater than 1, as specified by the ">1"">1" parameter.

SUMIF(Field1:Field5, ">1", { 11, 22, 33, 44, 55 })SUMIF(Field1:Field5; ">1"; { 11; 22; 33; 44; 55 })

Returns the sum of the elements of the { 11, 22, 33, 44, 55 }{ 11; 22; 33; 44; 55 } array, where only elements corresponding to elements in the Field1:Field5Field1:Field5 range greater than 1 are considered.

SUMIF({ "Eve", "Eve", "Bill" }, "Eve", { 10, 20, 30 })SUMIF({ "Eve"; "Eve"; "Bill" }; "Eve"; { 10; 20; 30 })

Returns 30 (10 + 2010 + 20), as only 10 and 20 correspond to "Eve" in the first array.

SUMIF({ 1, 2, 3 }, ">" & Field1, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; ">" & Field1; { 10; 20; 30 })

Determines which of the numbers of the { 1, 2, 3 }{ 1; 2; 3 } array are greater than the value of Field1 and returns the sum of the corresponding numbers of the { 10, 20, 30 }{ 10; 20; 30 } array. If Field1.ValueField1,Value is 1, then 50 is returned (20 + 3020 + 30).

SUMIF({ 1, 2, 3 }, "=2", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; "=2"; { 10; 20; 30 })

Returns 20, which corresponds to 2 in the array { 1, 2, 3 }{ 1; 2; 3 }, which is the only element of that array which satisfies the "=2""=2" condition.

SUMIF({ 1, 2, 3 }, "2", { 10, 20, 30 })SUMIF({ 1; 2; 3 }; "2"; { 10; 20; 30 })

Returns 20, which corresponds to 2 in the array { 1, 2, 3 }{ 1; 2; 3 }, which is the only element of that array which satisfies the "2""2" condition. Equality is implied when no operator is specified.

SUMIF({ 1, 2, 3 }, 2, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; 2; { 10; 20; 30 })

Returns 20, which corresponds to 2 in the array { 1, 2, 3 }{ 1; 2; 3 }, which is the only element of that array which satisfies the 22 condition. When a plain value is given as the second parameter, equality is implied. If only values equal to another value should be considered, using a plain value instead of a value enclosed in a text string is preferable, as errors can be detected at an earlier stage.

SUMIF({ 1.1, 1.2, 1.3 }, ">1.1", { 11, 12, 13 })SUMIF({ 1,1; 1,2; 1,3 }; ">1.1"; { 11; 12; 13 })

Returns 25 (12 + 1312 + 13). It does not return 36 (11 + 12 + 1311 + 12 + 13), as only 1.2 and 1.3 are greater than 1.1, as specified by the ">1.1"">1.1" parameter. A decimal separator appropriate for the language of the app should be used. If that language is French, for instance, a decimal comma should be used ("1,1" instead of "1.1").

SUMIF({ "car", "cat" }, "ca?", { 10, 100 })SUMIF({ "car"; "cat" }; "ca?"; { 10; 100 })

Returns 110 (10 + 10010 + 100), because both "car" and "cat" match the wildcard "ca?". ? matches exactly one (arbitrary) character.

SUMIF({ "car", "card" }, "ca*", { 10, 100 })SUMIF({ "car"; "card" }; "ca*"; { 10; 100 })

Returns 110 (10 + 10010 + 100), because both "car" and "card" match the wildcard "ca*". * matches zero, one or several (arbitrary) characters.

SUMIF({ "car", "ca*" }, "ca~*", { 10, 100 })SUMIF({ "car"; "ca*" }; "ca~*"; { 10; 100 })

Returns 100, because only "ca*" matches the wildcard "ca~*". ~ written before any other character matches it verbatim, meaning that * does not have special meaning here.

SUMIF({ 1, 2, 3 }, Element > 1, { 10, 20, 30 })SUMIF({ 1; 2; 3 }; Element > 1; { 10; 20; 30 })

Returns 50 (20 + 3020 + 30). It does not return 60 (10 + 20 + 3010 + 20 + 30), as only 2 and 3 of the first array are greater than 1, as specified by the Element > 1Element > 1 parameter. This example uses a formula fragment instead of a text string. It is invoked once for every array element considered, and is expected to return TRUE if the value should be considered and FALSE otherwise. To do its work, it has access to the Element value, which is the value under consideration.

SUMIF({ 1, 2, 3 }, (Element > 1) && ISODD(Element), { 10, 20, 30 })SUMIF({ 1; 2; 3 }; (Element > 1) && ISODD(Element); { 10; 20; 30 })

Returns 30, as only 3 in the first array is both greater than 1 and is an odd number and it corresponds to 30 in the second array. Formula fragments have access to the full power of the formula language, enabling complex conditions. && means logical "and," || means logical "or" and ! means logical negation.

SUM(FILTER({ 10, 20, 30 }, { 1, 2, 3 } > 1))SUM(FILTER({ 10; 20; 30 }; { 1; 2; 3 } > 1))

Returns 50 (20 + 3020 + 30). It does not return 60 (10 + 20 + 3010 + 20 + 30), as only 2 and 3 in the second array are greater than 1. FILTER returns a version of the first array, where elements corresponding to elements of the second array which failed the > 1 test are not present. Finally, SUM adds the remaining numbers (20 and 30) together and returns the sum.

REDUCE(FILTER({ 10, 20, 30 }, { 1, 2, 3 } > 1), (A, V) -> A + V, 0)REDUCE(FILTER({ 10; 20; 30 }; { 1; 2; 3 } > 1); (A; V) -> A + V; 0)

Returns 50 (20 + 3020 + 30). It does not return 60 (10 + 20 + 3010 + 20 + 30), as only 2 and 3 of the second array are greater than 1. REDUCE is a more flexible alternative to functions like SUM. Refer to its documentation to learn how it works.

SUMIF({ "123", "ab3" }, REGEXMATCH(Element, "\d\d\d"), { 10, 100 })SUMIF({ "123"; "ab3" }; REGEXMATCH(Element; "\d\d\d"); { 10; 100 })

Returns 10, because only "123" matches the "\d\d\d" regular expression (which only accepts exactly three numbers). Refer to the documentation of REGEXMATCH for more information.