# ROLLFORWARD_MUL
URL: https://docs.valsight.ai/rollforward-mul/
Description: ROLLFORWARD_MUL rolls the values of the Original Node forward, optionally influenced by one or more driver nodes whose effects are compounded multiplicatively.
**Category:** [Rollforward & time series](/rollforward-time-series/)

## Overview

The **ROLLFORWARD\_MUL** function **rolls the values of the Original Node forward, optionally influenced by one or more driver nodes whose effects are compounded multiplicatively.**

Use this function when multiple driver effects should compound with each other before being applied to the base node. Without drivers, the last value is carried forward as a flat projection.

> **Function alternative**
>
> The difference between this function and [ROLLFORWARD](/rollforward/) is how they treat multiple influence nodes. `ROLLFORWARD` **sums** the effects and then applies them to the original node. `ROLLFORWARD_MUL` **multiplies** the effects and then applies them to the original node.

## Syntax

`ROLLFORWARD_MUL('OriginalNode' [, 'DriverNode', ...])`

**Example usage:** `ROLLFORWARD_MUL('Revenue', 'Price Change', 'Volume Change')`

## Parameters

| Parameter         | Description                                                                                                                                                           | Type           | Required |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- | -------- |
| **Original Node** | Input node whose values are rolled forward, specified in single quotes (e.g.`'Revenue'`)                                                                              | Node reference | Yes      |
| **Driver Node**   | One or more driver nodes that influence the rollforward, specified in single quotes (e.g.`'Price Change'`). Multiple drivers can be provided as additional arguments. | Node reference | No       |

## Output shape

| Aspect         | Behavior                                                                                                                                                                             |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Dimensionality | Same as the Original Node                                                                                                                                                            |
| Values         | Original values are preserved for existing time periods. Future periods are projected from the last value, adjusted by cumulative compounded driver effects (or flat if no drivers). |
| Row count      | Expands to fill time periods within the horizon where driver data exists                                                                                                             |

## Watch out

* All input nodes (original and drivers) must have a **time level**.
* The driver's time level cannot be **coarser** than the original node's time level (e.g. yearly driver with monthly original data is not allowed).
* If a driver node is **not a percent node**, it is automatically converted to relative year-over-year changes before being applied.
* Original data values are **preserved as-is**. The rollforward only applies to time periods after the last existing data point.
* With **multiple drivers**, effects are **multiplied** per period (compounded), not summed. Use `ROLLFORWARD` if you need additive combination instead.
* Driver nodes are automatically **rolled up** to match the dimensionality of the Original Node if they have finer granularity.
* Driver partitions that do not match the Original Node are **ignored**. For example, a driver value for country FR is ignored if the Original Node has no FR data.
* If no driver nodes are specified, the **last value is projected forward** as a flat line (0% growth).

## Examples

### Compounding multiple drivers

This example shows how a level-less percentage driver and a country-specific percentage driver are combined. The driver effects are multiplied first and then applied to the base value.

**Original node:** `'Revenue'`

| Year | Country | Value |
| ---- | ------- | ----- |
| 2025 | DE      | 100   |
| 2025 | US      | 100   |

**Driver node:** `'Price Change'`

| Year | Value in % |
| ---- | ---------- |
| 2026 | 10%        |

**Driver node:** `'Volume Change'`

| Year | Country | Value in % |
| ---- | ------- | ---------- |
| 2026 | DE      | 10%        |
| 2026 | FR      | 20%        |

**Formula:** `ROLLFORWARD_MUL('Revenue', 'Price Change', 'Volume Change')`

| Year | Country | Calculation                   | Result |
| ---- | ------- | ----------------------------- | ------ |
| 2025 | DE      | N/A                           | 100    |
| 2025 | US      | N/A                           | 100    |
| 2026 | DE      | 100 × ((0.1 + 1) × (0.1 + 1)) | 121    |
| 2026 | US      | 100 × (0.1 + 1)               | 110    |

Both countries receive a 10% growth from the level-less `Price Change` node. In addition, the DE row receives another 10% growth from `Volume Change`, compounding to 21% total. The FR row from `Volume Change` is ignored because FR is not present in the base node. US only receives the price change because no volume change is defined for US.

### Comparing SUM vs MUL with the same inputs

This example highlights the difference between `ROLLFORWARD` (additive) and `ROLLFORWARD_MUL` (multiplicative).

**Original node:** `'Revenue'`

| Year | Revenue |
| ---- | ------- |
| 2026 | 1000    |

**Driver node:** `'Inflation'`

| Year | Value in % |
| ---- | ---------- |
| 2027 | 10%        |

**Driver node:** `'Growth'`

| Year | Value in % |
| ---- | ---------- |
| 2027 | 20%        |

**Formula:** `ROLLFORWARD_MUL('Revenue', 'Inflation', 'Growth')`

| Year | Calculation                  | Result |
| ---- | ---------------------------- | ------ |
| 2026 | N/A                          | 1000   |
| 2027 | 1000 × (0.1 + 1) × (0.2 + 1) | 1320   |

With `ROLLFORWARD` (additive), the same inputs would produce: 1000 + (1000 \* 0.1) + (1000 \* 0.2) = **1300**. The multiplicative version yields a higher result because the effects compound.

## Related

| Function                                        | When to use instead                                                                                                                                                        |
| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ROLLFORWARD\_ADVANCED](/rollforward-advanced/) | When you need a more configurable rollforward setup with explicit control over timing, base behavior, or advanced driver handling beyond the standard `ROLLFORWARD` logic. |
| [ROLLFORWARD](/rollforward/)                    | When you want to combine multiple driver effects additively before applying them to the base node instead of compounding them with each other.                             |