We have supported formula functions like SUM and PRODUCT for a long time now. What they have in common is that you supply multiple parameters and get a single result back.

These formula functions are used frequently by Calcapp authors, but provide
little value beyond adding or multiplying numbers together using `+`

and `*`

.
The formulas `SUM(Field1, 4)`

and `Field1 + 4`

do the exact same thing, which is
also true for the formulas `PRODUCT(4, 8, 16)`

and `4 * 8 * 16`

.

Functions like SUM and PRODUCT are about to become significantly more useful,
though, with the introduction of *ranges*. If you have more than a passing
familiarity with spreadsheets like Microsoft Excel, you have definitely
encountered ranges (whether or not you know them by that name).

In Excel, if cells A1 through A5 contain values you want to add together, you
can easily do so using the formula `=SUM(A1:A5)`

. By contrast, Calcapp has
historically forced you to enumerate all the values you wanted to add together,
by writing something like `SUM(A1, A2, A3, A4, A5)`

or `A1 + A2 + A3 + A4 + A5`

.
(Calcapp doesn’t require you to write `=`

before formulas.) Compared to using
ranges, that’s a lot more work.

The good news is that our upcoming release will support ranges. If you have five
number fields named `A1`

, `A2`

, `A3`

, `A4`

and `A5`

(appearing one after
another), adding their values together will be as easy as using the formula
`SUM(A1:A5)`

.

Calcapp authors don’t typically name their fields as though they were cells in a
spreadsheet grid. Rather, fields are automatically named using their labels as a
guide, so if you use the label “Maximum weight” for a field, the field is
assigned the name `MaximumWeight`

automatically. (To break the association
between the label and the name, simply type a new name manually in the name
field, to the left of the formula bar.) As such, ranges in Calcapp formulas will
typically look more like `SUM(MaximumWeight:IndividualWeight)`

than
`SUM(A1:A5)`

.

The formula `SUM(MaximumWeight:IndividualWeight)`

will add all values together
that belong to not only the fields `MaximumWeight`

and `IndividualWeight`

, but
all fields that appear between them in the app designer.

## Under the hood

In a spreadsheet, the cell reference `A1`

refers to the cell in the first column
and the first row of the spreadsheet grid and `A2`

refers to the cell in the
first column and the second row. The range `A1:A2`

refers to both of these
cells.

Spreadsheets also support something called *arrays*, which are similar to ranges
in that they hold multiple values. An *array constant* in a spreadsheet is
written between curly brackets, like `{ 2, 4 }`

, which is a value holding the
values 2 and 4. (As we have discussed earlier in this space,
we are adding support for arrays to Calcapp.)

Ranges and arrays are subtly different in spreadsheets. In Calcapp, there is no
spreadsheet grid, so a range and an array are one and the same. If `Field1`

,
`Field2`

and `Field3`

appear one after the other in the app designer, the
formulas `SUM(Field1:Field3)`

and `SUM({ Field1, Field2, Field3 })`

not only
return the same result, they look roughly identical to Calcapp. As such, a range
is simply a more concise way of writing an array.

## An example

What if you have five fields (`A1`

through `A5`

, appearing one after the other)
and you want to add their values together, but only those that are greater than
two? This has been possible with Calcapp ever since our first release, but you
had to use a long and cumbersome formula:

```
IF(A1 > 2, A1) + IF(A2 > 2, A2) + IF(A3 > 2, A3) + IF(A4 > 2, A4) + IF(A5 > 2,
A5)
```

(This formula would become even more unwieldy if you had, say, 100 fields instead of five.)

Spreadsheets make this considerably easier. The standard way to solve this is through the SUMIF formula function:

`SUMIF(A1:A5, ">2")`

Calcapp currently supports neither arrays nor ranges, explaining why we haven’t been able to support the SUMIF function earlier. This issue will be rectified by our next release, which will add support for not only SUMIF, but also SUMIFS, COUNTIF, COUNTIFS, AVERAGEIF, AVERAGEIFS, MINIFS and MAXIFS.

As teased earlier, Calcapp will not only support the formula
`SUMIF(A1:A5, ">2")`

(where the `">2"`

*condition* — determining which values
are considered – is expressed as a text string), but also an alternate form
which can be written like so:

`SUMIF(A1:A5, Item > 2)`

The second parameter is technically known as a *lambda* (or an *anonymous
function*), which returns a logical value (TRUE or FALSE), determining whether a
value should be considered. To help this lambda make this decision, the value
under consideration is available as `Item`

. (The name can be changed, but that’s
a topic for another blog post.)

Lambdas enable you to use complicated logic to determine whether a value should be considered:

`SUMIF(A1:A5, (Item > 2) && (Item < 10) && ISODD(Item)`

The example above only considers values which are greater than two, are less than ten and are odd. (In other words, only 3, 5, 7 and 9 are considered.)

## Modern Excel and dynamic arrays

One of the most exciting changes to come to Microsoft Excel are dynamic arrays, along with a number of new formula functions. Dynamic arrays make it much simpler to perform actions like filtering an array (returning a copy of said array only containing elements satisfying a certain condition with the FILTER function) and removing duplicates from an array (with the UNIQUE function).

We’re happy to announce that we will have full coverage of Microsoft’s new dynamic array functions when our next release becomes available.

Let’s return to the `SUMIF(A1:A5, ">2")`

example above. If you think about it,
there are two things going on here. First, the array consisting of the `A1:A5`

values is filtered to only contain values that are greater than two. Second,
these values are added together and returned.

Filtering the array can be accomplished using the new FILTER function, and summing them can be done using the SUM function. Here’s what that looks like:

`SUM(FILTER(A1:A5, A1:A5>2))`

FILTER is asked to filter the `A1:A5`

range, passed as the first parameter. The
second parameter is also an array, with the same size as the first parameter.
However, it is a logical array, consisting of TRUE and FALSE values. `A1:A5>2`

returns an array consisting of TRUE values where the value is greater than two,
and FALSE values elsewhere. That means that `{ 1, 2, 3, 4 }>2`

returns ```
{ FALSE,
FALSE, TRUE, TRUE }
```

, because only 3 and 4 are greater than two.

`SUM(FILTER(A1:A5, A1:A5>2))`

may look more cumbersome than `SUMIF(A1:A5, ">2")`

— and it is — but it provides far more flexibility. Which you wind up using
depends on your needs and on your preferences.

## When will this become available?

We’re in the last stages of our big formula revamp (which is the first step of our next-generation Calcapp 4 project). We hope that our next release, containing these features, will see the light of day in March.