IOCAN

# Math Input

## Overview

A **Math Input** combines **two inputs** with a single maths or bitwise

operation and reports the result as a new input. Despite the name it can divide,

multiply, add, subtract, or do bitwise AND / OR / XOR. Use it to derive a value —

a ratio, a sum, a difference — from two existing channels.

## Prerequisites & hardware

You need:

- A **first operand** input (the dividend) — referenced by alias.

- A **second operand** input (the divider) — referenced by alias.

Either operand can point at a [Constant Value Input](Constant_Value_Input) if

one side is a fixed number.

## Add it in the app

1. Add a new input and choose **Math / Divide Input** as the type.

2. Choose the **two source inputs**.

3. Give it a clear **alias** (e.g. `Gear Ratio`).

4. Pick the **operation**, set the **multiplier**, and set the **infinity value**.

## Settings reference

| Setting | Meaning | Unit | Range / values | Notes |

|---|---|---|---|---|

| **First operand** | The first input (the dividend in a divide) | — | an existing input (by alias) | Left-hand side of the operation. |

| **Second operand** | The second input (the divider in a divide) | — | an existing input (by alias) | Right-hand side of the operation. |

| **Operation** | The maths/bitwise operation applied | — | `Divide`, `Multiply`, `Add`, `Subtract`, `And`, `Or`, `Xor` | `And` / `Or` / `Xor` are **bitwise**, not logical. |

| **Multiplier** | The result is multiplied by this | — | sint32 | Use it to keep integer precision — e.g. `100` to express a ratio as hundredths. Set `1` for no scaling. |

| **Infinity value** | Value returned instead of dividing by zero | result's unit | sint32 | Used when the second operand is `0` in a `Divide`. Guards against divide-by-zero. |

**Formula:** the result is `(first OP second) * multiplier`. For example with

`Divide` and a **multiplier** of `100`, dividing `3000` by `1500` reports `200`

(i.e. 2.00).

## Common settings

Math / Divide Input also uses the shared setting — alias. See [Common IO Settings](Common_IO_Settings).

## Example — engine-to-output speed ratio

1. Type **Math / Divide Input**, alias `Speed Ratio`.

2. **First operand** = `Engine Speed`, **Second operand** = `Output Speed`.

3. **Operation** `Divide`.

4. **Multiplier** `100` so the ratio is reported in hundredths (2.50 reads as

   `250`).

5. **Infinity value** `0` so a stationary output (divider = 0) reports `0`

   instead of faulting.

## Troubleshooting

- **Result is always the infinity value:** the second operand is `0` (or near it)

  in a divide — check that source input.

- **Result looks rounded / always whole:** these are integer maths; raise the

  **multiplier** (e.g. `*100`) to keep fractional precision.

- **And / Or / Xor gives odd numbers:** remember they operate **bit by bit**, not

  as true/false — use a [Compare Input](Compare_Input) for logical conditions.

## Related

- [Constant Value Input](Constant_Value_Input) — supply a fixed operand.

- [Map Input](Map_Input) — reshape a single input through a curve.

- [Compare Input](Compare_Input) — turn a derived value into a true/false.