In our last post in January, we shared an update on our new formula engine, which will support arrays, ranges and lots of new functions. We closed by writing that we hoped that our new release would “see the light of day in March.”

The bad news is that our next release will take a little longer to reach you. The good news is that we’re pushing back the release for a good reason: we want to get two additional features done, which we think will make your day-to-day work with Calcapp easier.

Those features are **support for decimal commas in formulas** and
**much-improved formula documentation**.

## Decimal commas in formulas

Since its inception, Calcapp has only recognized decimal points (“.”) as decimal separators and commas (“,”) as parameter separators in formulas. This is in line with how numbers are written in countries like the US, Britain, Australia, New Zeeland, China, Japan, India and parts of Africa.

However, most parts of South America and Europe (including Russia), as well as parts of Africa, use decimal commas, making Calcapp formulas feel foreign in these countries. We often stress that you can frequently carry over formulas from spreadsheets to Calcapp simply by copying and pasting them, but this has sadly not worked well for our European and South American customers.

Apps produced with Calcapp have supported languages other than US English for more than three years now. Numbers are formatted according to the language of the app and functions like PARSENUMBER and FORMATNUMBER correctly handle the decimal separator of the configured language. In other words, apps have handled decimal commas correctly for years now, but not the app designer.

Programming languages typically use decimal points exclusively. Spreadsheets, however, with very few exceptions either allow the decimal separator to be set manually or follow the conventions of the host operating system. Spreadsheets that use decimal commas as decimal separators typically use semicolons (“;”) as parameter separators instead of commas.

Ironically, we’re a Swedish business, and decimal commas are exclusively used as decimal separators here. We’re not only Swedish, though, we’re also software developers. As programming languages exclusively support decimal points, it appears that we have grown a little too comfortable with decimal points to realize that this has been a major pain point our customers have experienced.

Enough is enough. We’re currently working on supporting decimal commas natively
in formulas. There will be a preference you’ll be able to toggle, which will
then make all formulas you edit use decimal commas as decimal separators instead
of decimal points. This means that you’ll soon be able to write ```
IF(Field1 >=
3.14, 1.23)
```

as `IF(Field1 >= 3,14; 1.23)`

.

The Calcapp 4 formula engine actually introduces another separator which is
affected by this change, in addition to decimal and parameter separators:
*statement separators*. As mentioned elsewhere, we’ll soon support
*action formulas*, which you’ll be able to associate with buttons. When a button
is activated, the formula is run, and these formulas will be able to execute
multiple actions (or “statements”), like sending multiple reports and
conditionally resetting fields.

To separate actions, or statements, you’ll need to use a statement separator. If Calcapp Creator is configured to use a decimal point, that’s a semicolon:

`IF(Field1 >= 3.14, RESET(Field1)); ALERT("Done!")`

This example resets *Field1* only if its value is greater than or equal to 3.14.
It then (unconditionally) displays the message “Done!” in a popup box. The two
statements are separated by a semicolon.

If Calcapp is configured to use a decimal point, you instead need to write two semicolons:

`IF(Field1 >= 3,14; RESET(Field1));; ALERT("Done!")`

## Much-improved function documentation

Back in 2016, we overhauled our formula engine, tweaking the way you write formulas slightly—to improve compatibility with spreadsheets—and added support for hundreds of spreadsheet functions. Overnight, we went from supporting around 20 functions to supporting 244. (Today, that number is 281.)

We knew that we needed documentation—for the functions themselves as well as their parameters—but writing high-quality documentation for hundreds of functions is not an easy task, and hard to justify for a product that was then in beta and hadn’t quite found its market yet. As a result, the documentation we did produce was quite terse.

Times have changed. The new functions we are adding can be used in many ways, and there may be alternatives to them that are preferable in some contexts. As a result, they need examples and room for a comprehensive discussion section.

We have re-written or expanded the documentation for most functions. There are exceptions, though. We have done little to change the documentation for most of the specialized statistical and financial functions we offer (like GAMMA.DIST, which still only “calculates values for a Gamma distribution,” with no additional content). All functions, except for compatibility functions, have at least one example, though.

The new documentation is far too voluminous to fit in the old reference sidebar. The plan is to host the documentation on the main website, and only include the first sentence and the parameter documentation in the reference sidebar. The full documentation will then be available from the sidebar through a link.

An added benefit of having the documentation available on the main website will be that you’ll more easily be able to make hard copies of it. Search engines will also have an easier time finding it.

To illustrate our new approach to documentation, the next section is a draft copy of our documentation for the new FILTER function.

## A draft version of the new FILTER function documentation

Filters the first array using the second parameter. For instance, ```
FILTER({
1, 2, 3 }, { FALSE, TRUE, TRUE })
```

returns `{ 2, 3 }`

. 1 is not
part of the returned array, as the corresponding element in the second array is
FALSE. 2 and 3 are both part of the returned array, as the corresponding
elements in the second array are both TRUE.

In other words, the returned array contains an element found in the first array only if the corresponding element in the second array is TRUE. The two arrays must be equal in size.

The second array is often not provided explicitly. Rather, an operation is
typically used that returns a logical array. For instance,
`FILTER(Field1:Field3, Field1:Field3 > 5)`

returns fields whose
values are greater than 5.

(The `Field1:Field3`

range is a short-hand way of expressing an array
containing *Field1* and *Field3*, as well as any fields that
appear between them, such as *Field2*. If only *Field2* appears
between the other two fields, `Field1:Field3`

and ```
{ Field1,
Field2, Field3 }
```

are equivalent.)

The second array does not need to reference the same array as the first array.
```
FILTER({ "Sally", "Ed", "Luke", "Jenny" }, { 90, 62, 91, 82 } >
85)
```

, where the first array contains student names and the second array
contains their test scores, returns an array of names of the students who scored
more than 85.

Use the SIZE function to determine the number of elements returned by FILTER.
`SIZE(FILTER(Field1:Field100, Item > 5))`

returns the number of
fields, in the `Field1:Field100`

range, whose values are greater than
5.

### Combining multiple conditions

Use the logical operators `||`

to express “logical or” (disjunction)
and `&&`

to express “logical and” (conjunction).
```
FILTER(Field1:Field3, (Field1:Field3 > 5) || (Field1:Field3 <
2))
```

returns those fields whose values are greater than 5 or less than 2.
```
FILTER(Field1:Field3, (Field1:Field3 > 5) &&
ISODD(Field1:Field3))
```

returns only those fields whose values are both
greater than 5 and are odd numbers.

Traditionally, spreadsheets use the `+`

operator to express “or” and
the `*`

operator to express “and.” Calcapp supports these operators
too. (The functions OR and AND cannot be used in this context, as they return a
single logical value, not a logical array.)

### Using a formula fragment to filter elements

Instead of passing a logical array as the second parameter, you can also use a
formula fragment which is expected to return TRUE if the element should be
included and FALSE otherwise. ```
FILTER({ 1, 2, 3 }, { 1, 2, 3 } >
1)
```

can also be expressed as ```
FILTER({ 1, 2, 3 }, Item >
1)
```

.

The formula fragment you supply as the second parameter is run once per element.
The element can be accessed as the `Item`

value. Moreover, the index
of the element (1 for the first element, 2 for the second element, etc) can be
accessed as the `Index`

value and the source array—given as the first
parameter to FILTER—as the `Source`

value. Including only the last
three elements can be achieved using a formula like this one:
`FILTER(SEQUENCE(100), Index > SIZE(Source) - 3)`

.

This variant is useful if you need to compare array elements only against themselves. It has the benefit of saving you from having to repeat the source array in the formula. This feature is specific to Calcapp and is not found in spreadsheets.

(Using this variant when you need to examine another array is possible, but is
not as convenient. ```
FILTER({ "Sally", "Ed", "Luke", "Jenny" }, { 90, 62,
91, 82 } > 85)
```

would be expressed as ```
FILTER({ "Sally", "Ed",
"Luke", "Jenny" }, INDEX({ 90, 62, 91, 82 }, Index) > 85)
```

, using the
`Index`

value together with the INDEX function to extract the correct
value from the other array.)

### Using FILTER instead of the *IF functions

When combined with other functions, FILTER can be used as a replacement for functions like AVERAGEIF, COUNTIF and SUMIF. These functions all boil down to filtering an array before applying an additional operation.

SUMIF, for instance, first filters an array based on a condition and then adds
the resulting numbers together, returning the result. ```
SUMIF({ 1, 10, 100,
1000 }, ">25")
```

returns 1100, because only 100 and 1000 are greater
than 25. `SUM(FILTER({ 1, 10, 100, 1000 }, Item > 25))`

and
`SUM(FILTER({ 1, 10, 100, 1000 }, { 1, 10, 100, 1000 } > 25))`

return the same result.

Similarly, `COUNTIF({ 1, 10, 100, 1000 }, ">25")`

returns 2,
because exactly two array elements are greater than 25. ```
SIZE(FILTER({ 1,
10, 100, 1000 }, Item > 25))
```

is equivalent—the FILTER invocation
returns `{ 100, 1000 }`

and SIZE returns the size of that array, 2.

`AVERAGEIF({ 1, 10, 100, 1000 }, ">25")`

returns 550, because that
is the average value between 100 and 1000. ```
AVERAGE(FILTER({ 1, 10, 100,
1000 }, Item > 25))
```

is equivalent.

When given a third parameter, AVERAGEIF, COUNTIF and SUMIF apply the condition
to the first array, while applying the operation (averaging, counting and
summing) to the first array. ```
SUMIF({ "Dave", "Sally", "Sally" }, "Sally",
{ 30, 40, 50 })
```

adds together 40 and 50, but not 30, as these numbers are
associated with the text string “Sally”, which the condition stipulates. The
equivalent formula using FILTER is ```
SUM(FILTER({ 30, 40, 50 }, { "Dave",
"Sally", "Sally" } = "Sally"))
```

.

### Using FILTER instead of the *IFS functions

AVERAGEIF, COUNTIF and SUMIF also come in versions designed to be used with multiple conditions: AVERAGEIFS, COUNTIFS and SUMIFS. There are also two *IFS functions with no *IF counterpart: MINIFS and MAXIFS, which return the smallest and largest number, respectively, from an array, provided that a number of conditions are met.

```
AVERAGEIFS({ 90, 62, 91, 82 }, { "F", "M", "M", "F" }, "F", { "CA", "CA",
"AZ", "AK" }, "AK")
```

returns an average of the test scores obtained by
female students who reside in Arkansas (abbreviated “AK”). Here, only one test
score matches (82) and is returned, because while two female students appear in
the data, only one of the students resides in Arkansas.

The equivalent formula using FILTER is ```
AVERAGE(FILTER({ 90, 62, 91, 82 },
({ "F", "M", "M", "F" } = "F") && ({ "CA", "CA", "AZ", "AK" } =
"AK")))
```

.

The FILTER version is far more versatile. AVERAGEIFS can only be used with
“logical and” and not “logical or” (or any other combination of logical
operations). What if we want the average of all test scores associated either
with female students or students residing in Arkansas? AVERAGEIFS does not
provide this feature, but using FILTER, it’s as easy as turning
`&&`

into `||`

: ```
AVERAGE(FILTER({ 90, 62, 91,
82 }, ({ "F", "M", "M", "F" } = "F") || ({ "CA", "CA", "AZ", "AK" } =
"AK")))
```

.

### FILTER, MAP and REDUCE

FILTER, MAP and REDUCE are commonly used together, as a data processing pipeline to transform data. FILTER is used to remove irrelevant elements from an array, MAP is used to transform the remaining elements and REDUCE, finally, is used to transform the resulting array to a single value.

Instead of REDUCE, a simpler function can be used which reduces an array of values to a single value. The most popular such functions are SUM (which adds all array elements together and returns the result) and AVERAGE (which returns an average of all the array elements).

A single formula can use multiple invocations of MAP and FILTER. For instance, an innermost FILTER invocation can filter the raw array once, and then hand this data to MAP, which transforms the filtered data. This data can then, once more, be given to FILTER, which filters out additional elements, and so.

The formula ```
SUM(FILTER(MAP(FILTER({ "$326.60", "€402.80", "$290.00",
"$128", "3002 SEK" }, STARTSWITH(Item, "$")), PARSENUMBER(Item)), Item >
200))
```

starts off with the text array ```
{ "$326.60", "€402.80",
"$290.00", "$128", "3002 SEK" }
```

, listing amounts in various currencies.
Working our way outwards from the array, FILTER is then applied to the array,
and uses the formula fragment `STARTSWITH(Item, "$")`

to only include
array elements which start with a dollar sign. That leaves ```
{ "$326.60",
"$290.00", "$128" }
```

. MAP is applied to this array, with the formula
fragment `PARSENUMBER(Item)`

, which converts the text array with
textual amounts to a number array holding the same amounts: ```
{ 326.6, 290,
128 }
```

. FILTER is then applied to this array using this formula fragment,
`Item > 200`

, which filters out all elements which are not greater
than 200. That leaves the array `{ 326.6, 290 }`

. Finally, SUM is
applied to this array, returning the grand total 616.60.

**Parameters:**

`values`

the values to filter.

`inclusions`

either an array or a formula fragment. If this parameter
is an array, it should be a logical array with the same size as the array of
values to filter. The returned array only contains values where the
corresponding element in this array is TRUE. If this parameter is a formula
fragment, it is run once per array element and is expected to return TRUE only
if the corresponding array element should be included in the returned array. To
do its work, it has access to the three named values `Item`

, the
array element under consideration, `Index`

, the index of the array
element (1 for the first element, 2 for the second element, etc) and finally
`Source`

, which is a reference to the array to filter, given as the
first parameter to FILTER.

`fallbackValues`

the values to return if no values matched the
filter. If there are no fallback values, an empty array is returned.

**Result:**
a filtered version of the given values. If no values match the filter, an empty
array is returned, unless the `fallbackValues`

parameter is provided,
in which case those values are returned instead.

**Examples:**

FILTER({ 1, 2, 3 }, { FALSE, TRUE, TRUE })

returns `{ 2, 3 }`

. 1 is not part of the returned array, as the
corresponding element in the second array is FALSE. 2 and 3 are both part of the
returned array, as the corresponding elements in the second array are both TRUE.

FILTER({ 1, 2, 3 }, { 1, 2, 3 } > 1)

returns an array containing the elements which are greater than one, ```
{ 2,
3 }
```

. `{ 1, 2, 3 } > 1`

returns the logical array ```
{
FALSE, TRUE, TRUE }
```

.

FILTER({ 1, 2, 3 }, Item > 1)

returns an array containing the elements which are greater than one, ```
{ 2,
3 }
```

. This variant uses a formula fragment, which is run once per array
element to determine whether the element should be part of the result. The
formula fragment is expected to return TRUE if that is the case.

SIZE(FILTER({ 1, 2, 3 }, Item > 1))

returns the number of array elements which are greater than one. As only 2 and 3 are greater than 1, 2 is returned. This variant uses a formula fragment, which is run once per array element to determine whether the element should be part of the result. The formula fragment is expected to return TRUE if that is the case.

FILTER({ 1, 2, 3 }, V -> V > 1)

returns an array containing the elements which are greater than one, ```
{ 2,
3 }
```

. This variant uses a formula fragment, which is run once per array
element to determine whether the element should be part of the result. The
formula fragment is expected to return TRUE if that is the case. This fragment
renames the `Item`

value, which references the array element under
consideration, to V. For longer formula fragments, renaming a value can make the
resulting formula fragment much smaller. Alternatively, renaming a value can be
used to give it a name that more accurately describes the value.

FILTER({ 10, 20, 30 }, Index >= 3)

returns `{ 3 }`

, as only the last array element has an index greater
than or equal to 3. (The first element has an index of 1, the second an index of
2, etc.)

FILTER({ 10, 20, 30 }, (V, I) -> I >= 3)

returns `{ 3 }`

, as only the last array element has an index greater
than or equal to 3. (The first element has an index of 1, the second an index of
2, etc.) Here, both the `Item`

and `Index`

values are
renamed to `V`

and `I`

, respectively. Even if the
`Item`

value is not needed, it still needs to be renamed, as it
appears before the `Index`

value.

FILTER({ 10, 20, 35 }, MOD(Item, 10) = 0)

returns array elements which are evenly divisible by 10, meaning that ```
{
10, 20 }
```

is returned.

FILTER({ 10, 20, 35 }, MOD(Item, Field1) = 0)

returns all array elements which are evenly divisible by
`Field1.Value</em>, provided by the user.`

FILTER({ 10, 20, 35 }, MOD(Item, 50) = 0)

returns array elements which are evenly divisible by 50. As there are no such array elements, an empty array is returned.

FILTER({ 10, 20, 35 }, MOD(Item, 50) = 0, { -50 })

returns array elements which are evenly divisible by 50. As there are no such
array elements, the third parameter is returned, `{ -50 }`

.

FILTER({ "Sally", "Luke", "Jenny" }, { 90, 91, 82 } > 85)

returns `{ "Sally", "Luke" }`

, which are the names of the students
who scored higher than 85, provided that the first array contains student names
and the second array contains their scores.

FILTER({ Field1, Field2 }.Color, { Field1, Field2 } > 3)

returns the colors of the fields whose values are greater than 3 as an array.

FILTER(Field1:Field100.Color, Field1:Field100 > 3)

returns the colors of the fields whose values are greater than 3 as an array.
`Field1:Field100`

is short-hand for an array which includes
*Field1*, *Field100* and all other fields which appear between
them.

FILTER(Field1:Field100.Value, MOD(Index, 5) = 0)

returns the values of every fifth field, among those listed.
`Field1:Field100`

is short-hand for an array which includes
*Field1*, *Field100* and all other fields which appear between
them.

SORT(UNIQUE(FILTER({ 32, 8, 8, 16, 4, 2, 1 }, Item > 7)))

returns `{ 8, 16, 32 }`

, which includes only those elements of the
`{ 32, 8, 8, 16, 4, 2, 1 }`

array which are greater than 7. UNIQUE
ensures that there are no duplicate values, and SORT ensures that the returned
array is sorted.

## Current status

We’re currently implementing support for commas as decimal separators in formulas. The new formula documentation has already been written. It has not yet been proof-read, though, nor have we written the software which will generate HTML documentation for the main website. (Should there be a search field? Should one page be generated for every function, or one page per category, which would group all text functions together? There are a few questions to resolve here.)

There are also many new button types (which will be able to do things like execute action formulas and open the system map app). They have not yet been implemented, but are not expected to be time-consuming.

We also need to ensure that the migration process is smooth, and that all paid apps will continue to run with no interruptions once the new formula engine is live.

This will be one of the biggest Calcapp upgrades we have ever released, and without a doubt the biggest update our formula engine has ever received. We’re anxious to get it into your hands and we look forward to seeing the amazing apps you’ll create with it.