Custom Formula Not Updating

Solution 1:

Excel Recalculates UDFs Only When Their Input Changes

You've created a User-Defined Function (UDF). Excel only runs the code of a UDF when the cell(s) that serve as input to the function change.

For example, suppose I have this UDF:

Public Function MyFunction(Target As Range)
MsgBox "The target cell's address is " &  Target.Address
End Function

And in cell A1 on my worksheet I reference the cell with the formula:

=MyFunction(A2)

During normal use of my workbook, the code of my UDF will only be called if there's a change to the contents of cell A2 or another cell referenced by a formula in A2.

Solutions

You can work around this behavior in several ways:

Force Excel to manual recalculate all of the formulas in the workbook even if they have not changed since the last calculation by pressing Ctrl+Alt+F9 on Windows and (I assume on Mac) Cmd+Alt+F9. If that doesn't work you can also try adding Shift which additionally rechecks dependent formulas before recalculating.
Include a volatile function in one of the cells referenced by your UDF. Do this by modifying the definition of your VBA function to accept an additional parameter:
```
Public Function MyFunction(Target As Range, Optional VolatileParameter As Variant)
```
Then edit the cell referencing your UDF to pass the result of a volatile function such as Now() to the UDF:
```
=MyFunction(A2,Now())
```
The net result will be that Excel will deem the cell containing the reference to your UDF as needing to be recaculated every time the worksheet is changed because it references a volatile function.
Edit the cell containing the UDF. Simply entering the cell then pressing Enter without making changes should be sufficient to trigger an update.
Create macro button that runs the following line of code:
```
Application.CalculateFull
```
Place the following code in your Workbook's Open event:
```
ActiveWorkbook.ForceFullCalculation = True
```
This causes Excel to always recalculate all formulas, regardless of whether it believes recalculation is required. This setting remains in effect until Excel is restarted.

Why Doesn't Excel Always Recalculate My UDF?

When Excel performs an automatic recalculation, it does not recalculate every single formula in the workbook. Instead it only updates those cells which contain formulas that refer to the most recently modified cell. This method avoids the much lengthier process of needlessly performing many calculations across the entire workbook only to come up with the same result for the vast majority of them.

With a UDF, the only references in the workbook of which Excel's calculation engine is aware are those identified in the function's inputs. Excel cannot examine the VBA code within the UDF and identify other cells that may influence the function's output. So while the function's author may construct the function to return different results based on any number of changes made in the workbook, the only cells Excel knows will change the function's result are the declared inputs. Therefore, changes to these cells are the only ones Excel pays attention to when deciding whether the UDF needs to be recalculated.

Solution 2:

An User Defined Function can be marked as volatile by itself, forcing the recalculation every time something changes in the workbook.

To do that, you have to call Application.Volatile from within the function.

Function ColorFunction(rColor As Range, rRange As Range, Optional SUM As Boolean)
Application.Volatile

Dim rCell As Range
Dim lCol As Long
Dim vResult
lCol = rColor.Interior.ColorIndex
    If SUM = True Then
       For Each rCell In rRange
        If rCell.Interior.ColorIndex = lCol Then
                vResult = WorksheetFunction.SUM(rCell) + vResult
        End If
       Next rCell
    Else
        For Each rCell In rRange
        If rCell.Interior.ColorIndex = lCol Then
                vResult = 1 + vResult
        End If
       Next rCell
End If
ColorFunction = vResult
End Function

Solution 3:

I hit this while hoping to update all user defined functions whenever an ActiveX textbox was changed even if they didn't affect linked cells which were used as inputs to the UDF. By accident I discovered that including any indirect cell reference in the function call appears to make it run whenever (seemingly) any other cell is edited. Presumably this is because excel has fewer guarantees about what it can trust to be unmodified when an indirect modifier is used. This is similar to Twisty Impersonator's second answer but adds less cruft to your vba code and formulas (so long as as least one range is used in the function).

Example: This function should always return the value in 'A2'

Public Function test(some_arg)
test = Sheets("Sheet1").Range("A2").Value
End Function

If you call it like =test(B1) it will not updated whenever A2 changes If you call it like =test(INDIRECT(ADDRESS(ROW(B1),COLUMN(B1))) it is functionally equivalent, and will update whenever A2 changes.

=test(INDIRECT("B1")) will also work and may be cleaner to understand for this example, but because "B1" is a string you won't be able to copy the formula across new values.

Solution 4:

Format changes (which includes Color Changes) are not considered events worthwhile a recalculation in Excel. That is not related to user defined functions. Therefore, any format change will not result in a recalculation.

That is not arbitrary, but makes some sense, as normally format changes do not influence anything else, so a recalculation - which is expensive - would be wasted. Since Excel now allows VB to use format information and react to it, this can become an issue, as it is for you.

You might be able to set OnChange functions for all cells, and trigger a recalculation there, but a format change might just not fire this function either (I never tried).

Solution 5:

None of these worked for me. I found that the only way I could get my UDF to calculate was to add the code below to the worksheet.activate event and point the focus to another sheet on open. Then when I clicked on the tab to the main sheet it worked.

Application.CalculateFullRebuild