Valsight

https://docs.valsight.com
Admin
Valsight is a financial modeling and business simulation platform that enables users to create...
Tokens:146,274
Snippets:2,238
Trust Score:8
Update:6 months ago
Show doc for...
Tokens:
Raw
### Scheduling Project Blueprints by Start Period

Source: https://docs.valsight.com/documentation/current/scheduleprojects

This example demonstrates scheduling project blueprints onto actual years using a timing node. The TimeLevel parameter is omitted, so the function assumes the lowest time level in the TimingNode.

```formula
SCHEDULEPROJECTS('ProjectKPI', 'TimingNode')
```

--------------------------------

### Example Usage of DISTRIBUTE

Source: https://docs.valsight.com/documentation/current/distribute

Basic example of distributing OPEX based on Revenue.

```text
DISTRIBUTE('OPEX', 'Revenue', "Product")
```

--------------------------------

### Full Example YAML Configuration for SAML

Source: https://docs.valsight.com/on-premise/latest/saml

An example of all available configuration keys for SAML, demonstrating various security and user profile settings.

```yaml
server:
    servlet:
        session:
            cookie:
                same-site: none
                secure: true
spring:
    security:
        saml2:
            relyingparty:
                registration:
                    SAML:
                        entity-id:
                        signing:
                            credentials:
                              - private-key-location:
                                certificate-location:
                        decryption:
                            credentials:
                              - private-key-location:
                                certificate-location: 
                        assertingparty:
                            metadata-uri: 
                        valsightSamlProperties:
                            loginSuccessfulUrl:
                            userProfileMapping:
                                username:
                                email:
                                fullName:
                            groupsAttribute:
                            mandatoryAttributes:
                                #example value
                                group: groupName
```

--------------------------------

### FILL_NA Examples

Source: https://docs.valsight.com/documentation/current/fill_na

Examples demonstrating the usage of the FILL_NA function.

```APIDOC
## Examples

### Filling missing time values with 0 (default)

This example fills missing values after pivoting the time dimension into columns. The default fill value is 0.

**Input node:**
**Year**| **Product**| **Value**
---|---|---
2026| Car| **100**
2028| Van| **90**

Pivoted `Input node` by dimension `"Time"`

**Product**| **2026**| **2028**
---|---|---
Car| 100| **N/A**
Van| **N/A**|  90

**Formula:** `FILL_NA('Input node')` = `FILL_NA('Input node', "Time", 0)`

**Result:**
**Product**| **2026**| **2028**
---|---|---
Car| 100| **0**
Van| **0**|  90

### Filling along a custom dimension with a custom value

This example fills missing values along the ProductDimension using 16 as the fill value instead of the default 0.

**Formula:** `FILL_NA('Input node', "ProductDimension", 16)`

**Result:**
**Year**| **Car**| **Van**
---|---|---
2026| 100| **16**
2028| **16**|  90
```

--------------------------------

### EXPAND Examples

Source: https://docs.valsight.com/documentation/current/expand

Illustrative examples of using the EXPAND function for different scenarios, including initializing a simulation node and adding dimensions.

```APIDOC
### Examples

#### Expand a scalar to full dimensionality
Initialize an empty simulation node with zeros across all years, regions, and products.
**Formula:**`EXPAND(0, "Year", "Region", "Product")`

**Input Table:**
**Year**| **Region**| **Product**| **→ EXPAND Result**  
---|---|---|---  
2025| EMEA| Alpha| **0**  
2025| EMEA| Beta| **0**  
2025| APAC| Alpha| **0**  
2025| APAC| Beta| **0**  
2026| EMEA| Alpha| **0**  
...| ...| ...| **...**  

The scalar `0` is replicated across every combination of Year × Region × Product. The result makes the simulation node eligible for use with ROLLFORWARD.

#### Expand a node to add a dimension
A growth-rate node only has a Year level, but should also include the Product level.
**Input node:** `Growth Rate`

**Input Table:**
**Year**| **Value**  
---|---  
2025| **0.03**  
2026| **0.05**  

**Formula:**`EXPAND('Growth Rate', "Product")`

**Output Table:**
**Year**| **Product**| **→ EXPAND Result**  
---|---|---  
2025| Alpha| **0.03**  
2025| Beta| **0.03**  
2026| Alpha| **0.05**  
2026| Beta| **0.05**  

The same growth rate per year is now available for each product.

#### Expand into a finer level within an existing dimension
A revenue node already has a `"Region"` level. You want to break it down to individual countries, a finer level in the same dimension hierarchy.
**Input node:** `Revenue Target`

**Input Table:**
**Year**| **Region**| **Value**  
---|---|---  
2025 | EMEA | **500**  
2025 | APAC | **300**  
**Total**| **800**  

**Formula:**`EXPAND('Revenue Target', "Country")`

**Output Table:**
**Year**| **Region**| **Country**| **→ EXPAND Result**  
---|---|---|---  
2025 | EMEA | Germany | **500**  
2025 | EMEA | France | **500**  
2025 | APAC | Japan | **300**  
2025 | APAC | Australia | **300**  
**Total**| **1600**  

Because `"Country"` is a finer level below `"Region"` in the hierarchy, EXPAND adds only the child values belonging to each region, not a full cross product of all countries with all regions. Note that the values are duplicated into each child row, so totals will increase.
```

--------------------------------

### RATIO Example Usage

Source: https://docs.valsight.com/documentation/current/ratio

Example of calling the RATIO function with two node references.

```text
RATIO('Revenue', 'Quantity')
```

--------------------------------

### Example Mail Server Configuration with SSL

Source: https://docs.valsight.com/on-premise/latest/mail-server

This is an example of how to configure the mail server for SSL connections. Ensure the 'port' and 'mail.smtp.socketFactory.port' values match.

```yaml
spring:
    mail:
        valsightProperties:
            enabled: true
            defaultFrom: "do-not-respond@valsight.local"
        host: smtp.gmail.com
        username: user@gmail.com
        password: password
        port: 465
        properties:
            mail.smtp.auth: true
            mail.smtp.socketFactory.port: 465
            mail.smtp.socketFactory.class: javax.net.ssl.SSLSocketFactory
            mail.smtp.socketFactory.fallback: false
```

--------------------------------

### Install Valsight Windows Service

Source: https://docs.valsight.com/on-premise/latest/install-valsight-as-a-windows-service

Execute these commands from an administrative command shell within the Valsight installation directory to install the service. Ensure the XML configuration is adapted before installation.

```bash
# Starting from the Valsight install directory, e.g. c:\valsight
# Make sure this is an admin cmd shell
cd windowsservice
cp valsightservice.xml.default valsightservice.xml
# Adapt the XML File, e.g. for more RAM or different JVM settings.
install_as_windows_service.bat
```

--------------------------------

### Example Mail Server Configuration with TLS

Source: https://docs.valsight.com/on-premise/latest/mail-server

This is an example of how to configure the mail server for TLS connections. Ensure the 'port' and 'mail.smtp.port' values match.

```yaml
spring:
    mail:
        valsightProperties:
            enabled: true
            defaultFrom: "do-not-respond@valsight.local"
        host: smtp.gmail.com
        username: user@gmail.com
        password: password
        port: 587
        properties:
            mail.smtp.starttls.enable: true
            mail.smtp.port: 587
```

--------------------------------

### Stretch Curves with Optional Start Point

Source: https://docs.valsight.com/documentation/current/stretch_curve

This example demonstrates stretching curves for different projects with individual stretch factors. Project B uses an explicit start point, while Project A defaults to a start point of 0.

```formula
STRETCH_CURVE('CurvesNode', 'StretchNode', 'StartNode')
```

--------------------------------

### RUNNINGSUM Example Usage

Source: https://docs.valsight.com/documentation/current/runningsum

Demonstrates how to use the RUNNINGSUM function with a specific node, such as 'Profit'.

```text
RUNNINGSUM('Profit')
```

--------------------------------

### YTD Example with Missing Quarters

Source: https://docs.valsight.com/documentation/current/ytd

This example demonstrates the year-to-date accumulation over quarters, illustrating how missing quarters within a year are filled and how missing quarters at the start of a year are handled.

```APIDOC
## YTD Example with Missing Quarters

### Description
This example shows the year-to-date accumulation over quarters, including how missing quarters inside a year are filled with the latest cumulative value while missing quarters at the start of a year are not added.

### Input Data
**Input node:** `Profit`

**Year**| **Quarter**| **Value**  
---|---|---
2025| 2025-Q1| **150**  
2025| 2025-Q2| **200**  
2025| 2025-Q3| **250**  
2026| 2026-Q2| **100**  
2026| 2026-Q3| **50**  
2026| 2026-Q4| **120**  
2027| 2027-Q1| **100**  
2027| 2027-Q2| **120**  
2027| 2027-Q4| **140**  

### Formula
`YTD('Profit')`

### Result
**Year**| **Quarter**| **→ YTD Result**  
---|---|---
2025| 2025-Q1| **150**  
2025| 2025-Q2| **350**  
2025| 2025-Q3| **600**  
2025| 2025-Q4| **600**  
2026| 2026-Q2| **100**  
2026| 2026-Q3| **150**  
2026| 2026-Q4| **270**  
2027| 2027-Q1| **100**  
2027| 2027-Q2| **220**  
2027| 2027-Q3| **220**  
2027| 2027-Q4| **360**  

### Explanation
2025-Q4 was filled with the cumulative sum (600) because Q3 was the last quarter with data. 2026-Q1 is not in the result because it was missing at the start of the year. 2027-Q3 carries forward the Q2 cumulative (220) because Q3 had no input data.
```

--------------------------------

### ROLLUP Function Example (Before Version 7.1)

Source: https://docs.valsight.com/documentation/current/rollup

Example of the deprecated syntax used before version 7.1.

```text
ROLLUP('Sales', "Time", "Year")
```

--------------------------------

### Example usage of EXPAND

Source: https://docs.valsight.com/documentation/current/expand

Basic example of expanding a node by a specific level.

```text
EXPAND('Growth Rate', "Product")
```

--------------------------------

### ROLLFORWARD Examples

Source: https://docs.valsight.com/documentation/current/rollforward

Illustrative examples demonstrating the use of the ROLLFORWARD function with different types of drivers.

```APIDOC
### Examples

#### Rollforward with a percentage driver
This example uses a percentage driver. Each future period applies the driver value to the latest rolled result.

**Input node:** `Revenue`
**Year**| **Value**  
---|---
2025| **95**  
2026| **100**  

**Input node:** `Inflation`
**Year**| **Value in %**  
---|---
2026| **0.02**  
2027| **0.1**  
2028| **0.2**  

**Formula:** `ROLLFORWARD('Revenue', 'Inflation')`

**Year**| **→ ROLLFORWARD Result**  
---|---
2025| **95**  
2026| **100**  
2027| **110**  
2028| **132**  

#### Rollforward with an absolute driver
If the driver node is not a percent node, ROLLFORWARD converts it into a yoy-growth effect before applying it to the latest rolled value.

**Input node:** `Revenue`
**Year**| **Value**  
---|---
2025| **95**  
2026| **100**  

**Input node:** `Market Size`
**Year**| **Value**  
---|---
2026| **10000**  
2027| **10100**  
2028| **10500**  

**Formula:** `ROLLFORWARD('Revenue', 'Market Size')`

**Year**| **→ ROLLFORWARD Result**  
---|---
2025| **95**  
2026| **100**  
2027| 100 + (10100/10000) = **101**  
2028| 101 + (10500/10100) = **102.03**  

#### Rollforward with multiple driver nodes
With multiple drivers, ROLLFORWARD sums the individual effects per period before applying them to the latest rolled value.

**Input node:** `Inflation`
**Year**| **Inflation**  
---|---
2026| **10%**  
2027| **10%**  
2028| **10%**  

**Input node:** `Growth`
**Year**| **Growth**  
---|---
2026| **20%**  
2027| **20%**  
2028| **20%**  

**Input node:** `Revenue`
**Year**| **Revenue**  
---|---
2026| **1000**  

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

**Year**| **→ ROLLFORWARD Result**  
---|---
2027| 1000 + (1000 * 0.1) + (1000 * 0.2) = **1300**  
2028| 1300 + (1300 * 0.1) + (1300 * 0.2) = **1690**
```

--------------------------------

### PREVIOUS Function Usage Example

Source: https://docs.valsight.com/documentation/current/previous

Example demonstrating how to retrieve the previous period's value using a specific base period.

```text
PREVIOUS('Cost', "Year", 'Initial Cost', "2025")
```

--------------------------------

### Example Usage of NONSIM

Source: https://docs.valsight.com/documentation/current/nonsim

Demonstrates a basic call to the NONSIM function with a single node reference.

```text
NONSIM('Revenue')
```

--------------------------------

### FINDFIRST Example: First Value Per Product

Source: https://docs.valsight.com/documentation/current/findfirst

This example demonstrates how FINDFIRST returns the earliest defined value for each product. Products with gaps retain only the first year's value.

```text
FINDFIRST('Node A')
```

```text
FINDFIRST('Node A', "Year")
```

--------------------------------

### MIN Function Examples

Source: https://docs.valsight.com/documentation/current/min

Illustrates practical use cases of the MIN function with sample data.

```APIDOC
## Examples

### Row-wise minimum across two inputs
This example shows MIN applied both to two input nodes and to a node combined with a fixed numeric threshold.

**Input node:** `A`
**Year**| **Value**  
---|---
2025| **32**  
2026| **-42**  
2027| **-17**  

**Input node:** `B`
**Year**| **Value**  
---|---
2025| **41**  
2026| **12**  
2027| **-25**  

**Formula:** `MIN('A', 'B')`
**Year**| **→ MIN Result**  
---|---
2025| **32**  
2026| **-42**  
2027| **-25**  

**Formula:** `MIN('A', 12)`
**Year**| **→ MIN Result**  
---|---
2025| **12**  
2026| **-42**  
2027| **-17**  

### Using MIN as a cap (clamp values to an upper limit)
A common pattern: use `MIN('Node', threshold)` to ensure no value exceeds a defined maximum.

**Input node:** `Discount Rate`
**Year**| **Value**  
---|---
2025 | **0.05**  
2026 | **0.12**  
2027 | **0.08**  
2028 | **0.25**  

**Formula:** `MIN('Discount Rate', 0.15)`
**Year**| **- > MIN Result**  
---|---
2025 | **0.05**  
2026 | **0.12**  
2027 | **0.08**  
2028 | **0.15**  

Values above 15% are capped at 0.15. Values already below the threshold are kept as-is.
```

--------------------------------

### ROUND Function Usage Examples

Source: https://docs.valsight.com/documentation/current/round

Examples demonstrating different rounding modes and scales applied to a decimal node.

```text
ROUND('Revenue', "HALF_UP", 2)
```

```text
ROUND('DecimalNode')
```

```text
ROUND('DecimalNode', "UP")
```

```text
ROUND('DecimalNode', "DOWN", -1)
```

--------------------------------

### NONSIM Examples

Source: https://docs.valsight.com/documentation/current/nonsim

Illustrative examples demonstrating the behavior of the NONSIM function in different scenarios, including baseline calculations and comparisons between SCENARIO and PROJECT modes.

```APIDOC
## NONSIM Examples

### Baseline values without assumptions
This example shows the baseline result of multiplying two nodes when no assumptions or variable overrides are applied. The project default variable $MY_VAR is set to 10.

**Project default variables:** $MY_VAR = 10

**Input node:** `Node 1`
| Year | Value |
|---|---|
| 2025 | $MY_VAR = **10** |
| 2026 | $MY_VAR = **10** |
| 2027 | $MY_VAR = **10** |
| 2028 | $MY_VAR = **10** |

**Input node:** `Node 2`
| Year | Value |
|---|---|
| 2025 | **1** |
| 2026 | **1** |
| 2027 | **1** |
| 2028 | **1** |

**Formula:** `'Node 1' * 'Node 2'`
| Year | Value |
|---|---|
| 2025 | **10** |
| 2026 | **10** |
| 2027 | **10** |
| 2028 | **10** |

These are the baseline results with no assumptions applied.

### Values with scenario overrides and assumptions
This example shows how the same nodes look when a scenario overrides $MY_VAR to 20 and assumptions are activated on both nodes.

**Variable override via scenario:** $MY_VAR = 20

**Input node:** `Node 1` (with overridden $MY_VAR as 'Base' and activated assumptions as 'Change')
| Year | Base | Change | Result |
|---|---|---|---|
| 2025 | 20 | 0 | **20** |
| 2026 | 20 | 10 | **30** |
| 2027 | 20 | 20 | **40** |
| 2028 | 20 | 30 | **50** |

**Input node:** `Node 2` (with the initial measures as 'Base' and activated assumptions as 'Change')
| Year | Base | Change | Result |
|---|---|---|---|
| 2025 | 1 | 1 | **2** |
| 2026 | 1 | 2 | **3** |
| 2027 | 1 | 3 | **4** |
| 2028 | 1 | 4 | **5** |

**Formula:** `'Node 1' * 'Node 2'`
**Result node:**
| Year | Base (Node 1 * Node 2) | Change | Result |
|---|---|---|---|
| 2025 | 20 * 2 | 5 | **45** |
| 2026 | 30 * 3 | 5 | **95** |
| 2027 | 40 * 4 | 5 | **165** |
| 2028 | 50 * 5 | 5 | **255** |

### Comparing SCENARIO vs PROJECT mode
This example shows the difference between the two modes. NONSIM removes only the Result Node's own assumptions (+5 Change) but keeps upstream assumptions on Node 1 and Node 2.

**Formula:** `NONSIM('Result Node')` = `NONSIM('Result Node', "SCENARIO")`
| Year | → NONSIM Result |
|---|---|
| 2025 | 20 * 2 = **40** |
| 2026 | 30 * 3 = **90** |
| 2027 | 40 * 4 = **160** |
| 2028 | 50 * 5 = **250** |

The Result Node's own assumption (+5) is removed, but Node 1 and Node 2 keep their assumptions and the scenario's variable override ($MY_VAR = 20).

**Formula:** `NONSIM('Result Node', "PROJECT")`
| Year | → NONSIM Result |
|---|---|
| 2025 | 10 * 2 = **20** |
| 2026 | (10 + 10) * 3 = **60** |
| 2027 | (10 + 20) * 4 = **120** |
| 2028 | (10 + 30) * 5 = **200** |

PROJECT mode reverts $MY_VAR to the project default (10), so Node 1's base becomes 10 instead of 20. Node 1's upstream assumptions (Change = 0, 10, 20, 30) and Node 2's assumptions are still applied.
```

--------------------------------

### YOY_REL Example Usage

Source: https://docs.valsight.com/documentation/current/yoy_rel

Demonstrates how to use the YOY_REL function with a specific input node.

```text
YOY_REL('Revenue')
```

--------------------------------

### LTE Example: Comparing Input Nodes

Source: https://docs.valsight.com/documentation/current/lte

This example demonstrates comparing two input nodes, 'A' and 'B', row by row using the LTE function. The output indicates where 'A' is less than or equal to 'B'.

```text
LTE('A', 'B')
```

--------------------------------

### MOVINGSUM Syntax Example

Source: https://docs.valsight.com/documentation/current/movingsum

Basic syntax usage for the MOVINGSUM function.

```text
MOVINGSUM('Revenue', "Month", 12)
```

--------------------------------

### Approximate Threshold Lookup Example

Source: https://docs.valsight.com/documentation/current/lookup

This example demonstrates how to use the LOOKUP function to find a salary against a sorted threshold table and return the corresponding tax value. Ensure the index column is sorted in ascending order.

```Valsight Formula
LOOKUP('Lookup Value', 'Index', 'Return Value')
```

--------------------------------

### REBOOK Function Syntax and Usage

Source: https://docs.valsight.com/documentation/current/rebook

Basic syntax and example usage for the REBOOK function.

```text
REBOOK('Node', "Level", "OldValue", "NewValue" [, "FilterOperation"])
```

```text
REBOOK('Revenue', "Segment", "MINI", "LARGE")
```

--------------------------------

### Example Usage of MULTIPLY

Source: https://docs.valsight.com/documentation/current/multiply

Demonstrates how to call the MULTIPLY function with a specific validation option.

```text
MULTIPLY('Volume', 'Price', "FailOnMissing")
```

--------------------------------

### FINDFIRST Function Combination with TRUE

Source: https://docs.valsight.com/documentation/current/findfirst

Often used together with TRUE to generate starting values, for example in combination with SCHEDULEPROJECTS.

```text
TRUE(FINDFIRST('Node'))
```

--------------------------------

### Calculate a periodic payment with PMT

Source: https://docs.valsight.com/documentation/current/pmt

Example of a standard annuity setup using the PMT function to calculate the required periodic payment.

```text
PMT('Rate', 'Nper', 'Pv', 'Fv', "Type")
```

--------------------------------

### YTD with Missing Quarters Example

Source: https://docs.valsight.com/documentation/current/ytd

Demonstrates year-to-date accumulation with missing quarters. Missing quarters within a year are filled with the last cumulative value, while missing quarters at the start of a year are not included. The input node must have a time level of at least Quarter.

```text
YTD('Profit')
```

--------------------------------

### Configure Database Connection in YAML

Source: https://docs.valsight.com/on-premise/latest/on-premise-installation-guide

Example configuration for connecting to a PostgreSQL database. Ensure the driver and dialect match your database. For MSSQL, uncomment and adjust the alternative settings.

```yaml
# Excerpt from conf/config.yml#
environments:
    production:
        dataSource:
            driverClassName: org.postgresql.Driver
            sqlDialect: org.hibernate.dialect.PostgreSQLDialect

            # Alternative MSSQL:
            #   driverClassName: com.microsoft.sqlserver.jdbc.SQLServerDriver
            #   sqlDialect: org.hibernate.dialect.SQLServerDialect
            #
            username:
            password:
            url: jdbc:postgresql://localhost:5432/es-rest-service


```

--------------------------------

### Distributing a Single Value with Gradual Ramp-up

Source: https://docs.valsight.com/documentation/current/timelag

Example demonstrating how a single investment value is phased in over time using a lag profile.

```text
TIMELAG('Cost', 'LagProfile', "Year")
```

--------------------------------

### FILLMISSING Example Usage

Source: https://docs.valsight.com/documentation/current/fillmissing

Simple usage examples for the FILLMISSING function.

```text
FILLMISSING('Revenue')
```

```text
FILLMISSING('Input node')
```

```text
FILLMISSING('Input node', "ProductDimension", 1)
```

--------------------------------

### Create an empty data room for simulation

Source: https://docs.valsight.com/documentation/current/dimensionality-hierarchies

Use to initialize a node with the required dimensionality.

```text
EXPAND(0, "Level1", "Level2")
```

--------------------------------

### DIVIDE example usage

Source: https://docs.valsight.com/documentation/current/divide

Example of calling the DIVIDE function with the FailOnMissing validation mode.

```text
DIVIDE('Profit', 'Revenue', "FailOnMissing")
```

--------------------------------

### DISTRIBUTE Example: Across All Additional Levels

Source: https://docs.valsight.com/documentation/current/distribute

Demonstrates how to use the DISTRIBUTE function to distribute values across all available levels in the Distribution Node.

```APIDOC
## DISTRIBUTE Example: Across All Additional Levels

This example distributes OPEX to the detailed product level using revenue as the weighting node.

**Input node:** `'OPEX'`
**Year**| **OPEX**  
---|---
2025| **2000**  
2026| **4000**  
2027| **12000**  

**Input node:** `'Revenue'`
**Product Line**| **Product**| **2025**| **2026**  
---|---|---|---
M| M1| **100**| **200**  
M| M2| **300**| **600**  
Z| Z3| **400**| **800**  

**Formula:** `DISTRIBUTE('OPEX', 'Revenue')`

Product Dimension| Year  
---|---
**Product Line**| **Product**| **2025**| **2026**| **2027**  
M | M1| 2000 * 100 / 800 = **250**|  4000 * 200 / 1600 = **500**|  12000 / 4 = **3000**  
M2| 2000 * 300 / 800 = **750**|  4000 * 600 / 1600 = **1500**|  12000 / 4 = **3000**  
Z | Z3| 2000 * 400 / 800 = **1000**|  4000 * 800 / 1600 = **2000**|  12000 / 4 = **3000**  
X| X4| -| -| 12000 / 4 = **3000**  

**Totals**| **2000**| **4000**| **12000**  

For 2025 and 2026, each product's share is calculated as: OPEX * (product revenue / total revenue). For 2027, no revenue data exists, so the value is evenly distributed across all 4 products. The totals are preserved in every year.
```

--------------------------------

### MAX Function Example Usage

Source: https://docs.valsight.com/documentation/current/max

Example of using the MAX function with a node and a numeric constant.

```text
MAX('Revenue', 0)
```

--------------------------------

### Access Project Spaces in XML

Source: https://docs.valsight.com/documentation/current/xml-access

Example URL to retrieve project spaces in XML format. This assumes the default JSON representation is available at the base URL.

```http
https://valsight-url/v1/projectSpaces?format=xml
```

--------------------------------

### ROLLUP Deprecated Syntax Example

Source: https://docs.valsight.com/documentation/current/rollup

An example of the deprecated syntax for the ROLLUP function, including dimension names.

```text
ROLLUP('Sales', "Time", "Year", "Product", "Product Group")
```

--------------------------------

### Verify GPG Signature for Releases

Source: https://docs.valsight.com/trust/latest/digitally-signed-releases

Import the public key once and use it to verify the signature of downloaded release files.

```bash
# Import the public key into the local key store
gpg --import Valsight_GmbH_Releases_-_Level_1.pub

# Verify the signature, replace X.X.X with version number
gpg --verify valsight-server.sig valsight-server-X.X.X.zip
```

--------------------------------

### FV Function Formula Example

Source: https://docs.valsight.com/documentation/current/fv

Example formula usage for calculating the future value of a recurring annuity.

```text
FV('Rate', 'Nper', 'Pmt', 'Pv', "Type")
```

--------------------------------

### MOVINGAVG Example Usage

Source: https://docs.valsight.com/documentation/current/movingavg

Illustrates how to call the MOVINGAVG function with specific parameters for revenue data over a monthly time level with a window of 3.

```text
MOVINGAVG('Revenue', "Month", 3)
```

--------------------------------

### Reference project variables

Source: https://docs.valsight.com/documentation/current/formula-basics

Use the $ prefix to select project variables as placeholders.

```text
$FORECAST_START
```

--------------------------------

### Valsight API Client Example Script

Source: https://docs.valsight.com/documentation/current/valsight-api-client

A Groovy script demonstrating how to parse command-line arguments using Apache Commons CLI and interact with the Valsight API to fetch project details, models, and data sources. It utilizes the `client` object for API calls and `log` for output.

```groovy
import groovy.json.JsonOutput
import org.apache.commons.cli.CommandLine
import org.apache.commons.cli.CommandLineParser
import org.apache.commons.cli.DefaultParser
import org.apache.commons.cli.Options

// static imports are required for autocompletion

import static com.valsight.rest.ScriptDelegate.client
import static com.valsight.rest.ScriptDelegate.log

// Variables/environment passed to the script:
//
// ValsightRESTClient client: a connected/logged in ValsightRESTClient instance (unless --serverless mode is specified)
// String[] args: the list of all script arguments
// Logger log: a logger with the name of the script



// Example: parsing command line arguments
// The script is passed all remaining command line arguments after the script launcher
// has processed its arguments (e.g. server url / username)
// You can use any mechanism to parse the args, commons-cli is in the classpath and is recommended

log.info "All args: ${args}"

Options options = new Options()
options.addOption('project', 'project-key', true, '')

CommandLineParser parser = new DefaultParser()
CommandLine cmd = parser.parse(options, args)

log.info "Options/flags: ${cmd.options.collectEntries { [it.opt, it.value] }} "
log.info "positional arguments: ${cmd.args}"

// Example: using the ValsightRESTClient object

List projects = client.findAllProjectSpaces()
String projectFilter = cmd.getOptionValue('project')
if (projectFilter  != null) {
    projects  = projects.findAll { it.businessKey.equals(projectFilter) }
} else {
    log.error "Please specify a project."
    System.exit(1)
}
Long projectID = projects[0]['id']
String projectName = projects[0]['name']
String projectKey = projects[0]['businessKey']

log.info "Working on Project $projectName (Key: $projectKey, ID: $projectID)"

// For more convenient method calls on client, you may use the standard Groovy .with {}


log.info "The following models and nodes are found in the project"

client.with {
    getObjects('models',['project':projectID ]).each { model ->
        log.info  model['name']
        log.info "Status: "
        log.info client.getPath("models/${model['id']}/validate").isEmpty() ? '  Valid' : "  Invalid: ${client.getPath("models/${model['id']}/validate").toString()}"
        model['nodes'].each { nodeId ->
            log.info "  " + getObject('nodes', nodeId)['name']
        }
    }
    log.info "The following datasources are available"

    getObjects('externalDataSources',['project':projectID ]).each { ds ->
        log.info "  ${ds['name']}  (${ds['id']})"
        log.info "Status: " + client.getPath("externalDataSources/${ds['id']}/status").toString()
    }

}





```

--------------------------------

### Basic EXPANDSINGLE usage

Source: https://docs.valsight.com/documentation/current/expandsingle

Demonstrates the syntax for expanding a node by a single level and value.

```text
EXPANDSINGLE('Sales', "Year", "2025")
```

--------------------------------

### Connect and List Projects with Python

Source: https://docs.valsight.com/on-premise/latest/python-example

Use this script to connect to the Valsight API, authenticate using an API key, and retrieve a list of all projects in your instance. The script stores the session cookie for subsequent requests.

```python
import requests, os,sys, json
baseurl = "https://instancename.valsight.eu/v1/"
username = 'username-as-shown-on-userpage'
api_key = '5bc333fe-xxxx-xxxx-xxxx-c04513aa2a0f'

session = requests.Session()
response = session.post( baseurl+ "apiKey", data={'username': username,'api_key': api_key})
r = session.get(baseurl+"projectSpaces/")
for p in json.loads(r.text):
    print("ID: %i 	Business Key: %s 	Name: %s" %(p["id"], p['businessKey'], p['name']))
```

--------------------------------

### Example: Default Behavior (Ignoring Missing Values)

Source: https://docs.valsight.com/documentation/current/yoy_rel

This example demonstrates the YOY_REL function with its default behavior of ignoring missing values. The input node is 'Profit'.

```APIDOC
## Example: Default Behavior (Ignoring Missing Values)

### Input Data
**Input node:** `Profit`
**Year**| **Value**
---|---
2025| **200**
2026| **300**
2027| **450**
2028| **500**
2030| **100**

### Formula
`YOY_REL('Profit')` which is equivalent to `YOY_REL('Profit', "IGNORE_MISSING")`

### Result
**Year**| **→ YOY_REL Result**
---|---
2026| (300 - 200) / 200 = **0.5**
2027| (450 - 300) / 300 = **0.5**
2028| (500 - 450) / 450 = **0.11**

**Note:** The first year (2025) is dropped as there's no previous year. Year 2030 is also excluded because the missing year 2029 prevents a valid comparison.
```

--------------------------------

### ROLLFORWARD_ADVANCED with Seasonality over Quarters

Source: https://docs.valsight.com/documentation/current/rollforward-1

This example demonstrates using ROLLFORWARD_ADVANCED with a 'Quarters' time level and a window size of 4 to project data considering quarterly seasonality.

```text
ROLLFORWARD_ADVANCED('input', [], "Quarter", "2019-Q1", "2020-Q4", 4)
```

--------------------------------

### ROLLFORWARD_ADVANCED with Custom Start and End Years

Source: https://docs.valsight.com/documentation/current/rollforward-1

Configure the 'start' and 'end' parameters to define a specific range for data projection, overriding the default year range.

```text
ROLLFORWARD_ADVANCED('input', [], "Year", "2019", "2021")
```

--------------------------------

### Baseline Calculation Example

Source: https://docs.valsight.com/documentation/current/nonsim

Shows the multiplication of two nodes without any assumptions or scenario overrides, using project default variables.

```text
'Node 1' * 'Node 2'
```

--------------------------------

### Example: Treating Missing Values as Zero

Source: https://docs.valsight.com/documentation/current/yoy_rel

This example shows how the YOY_REL function behaves when missing values are treated as zero using the 'MISSING_AS_ZERO' option. The input node is 'Profit'.

```APIDOC
## Example: Treating Missing Values as Zero

### Input Data
**Input node:** `Profit`
**Year**| **Value**
---|---
2025| **200**
2026| **300**
2027| **450**
2028| **500**
2030| **100**

### Formula
`YOY_REL('Profit', "MISSING_AS_ZERO")`

### Result
**Year**| **→ YOY_REL Result**
---|---
2026| (300 - 200) / 200 = **0.5**
2027| (450 - 300) / 300 = **0.5**
2028| (500 - 450) / 450 = **0.11**
2029| (0 - 500) / 500 = **-1**
~~2030~~| (100 - 0) / 0 = **division by zero** results in entry not being present in result

**Note:** Year 2029 shows a -1 result (100% decline) because the missing value was treated as 0. Year 2030's entry is dropped due to division by zero.
```

--------------------------------

### Running the Valsight Client

Source: https://docs.valsight.com/documentation/current/valsight-api-client

Command to execute the Valsight client JAR. Specify the script file and server connection details (URL, username, password, or API key).

```bash
java -jar valsight-client-launcher-x.x.jar <script-file> (-s <server-url> | --serverless) ([-u <username> -p <password>] | [-u <username> -k <API key>]) <other-script-args>
```

--------------------------------

### POWER Function Example: Raising one node to the power of another

Source: https://docs.valsight.com/documentation/current/power

This example demonstrates how to use the POWER function with two input nodes, one for the base and one for the exponent.

```APIDOC
## POWER Function Example: Raising one node to the power of another

### Description
This example shows POWER applied row-wise using node A as the base and node B as the exponent. Here the exponent is constant at 2, so the result squares each base value.

**Input node:** `Base`
**Year**| **Value**  
---|---
2025| **2**  
2026| **3**  
2027| **4.5**  

**Input node:** `Exponent`
**Year**| **Value**  
---|---
2025| **2**  
2026| **2**  
2027| **2**  

**Formula:** `POWER('Base', 'Exponent')`

**Year**| **→ POWER Result**  
---|---
2025| **4**  
2026| **9**  
2027| **20.25**  
```

--------------------------------

### OR Function Example

Source: https://docs.valsight.com/documentation/current/or

This example demonstrates the OR function's behavior. It returns 1 when at least one of the two inputs is true. Non-zero values are treated as true, while 0 is treated as false.

```text
OR('A', 'B')
```

--------------------------------

### Modulo Operation Example

Source: https://docs.valsight.com/documentation/current/mod

Illustrates the results of the MOD function with sample data, including cases with missing matches and division by zero. Note that division by zero results in no output for that row.

```text
MOD('Node A', 'Node B')
```
Tokens:
Raw