​
MOD (math/modulus/float)

The MOD node calculates the modulus (remainder) of dividing the first input by the second input. It operates on floating-point numbers.

​
Inputs

  1. a (float, default: 0): The dividend, or the number to be divided.
  2. b (float, default: 0): The divisor, or the number to divide by.

​
Outputs

  1. result (float): The remainder after dividing a by b.

​
Configuration

This node has no configuration options.

​
Usage

  1. Connect a node providing the dividend (number to be divided) to the a input.
  2. Connect a node providing the divisor (number to divide by) to the b input.
  3. The result output will emit the remainder after dividing a by b.

​
Example

Consider a spell where you want to create a repeating color pattern based on the index of each item in a list. You can use the MOD node to get the remainder when dividing the index by the number of colors, ensuring the color index always stays within the valid range. 
{
  "nodes": [
    {
      "type": "list/generate",
      "id": "1",
      "configuration": {
        "count": 10
      },
      "outputs": {
        "list": "2.list"
      }
    },
    {
      "type": "list/map",
      "id": "2",
      "inputs": {
        "list": "1.list"
      },
      "outputs": {
        "list": "OUT"
      },
      "spells": {
        "spell": {
          "nodes": [
            {
              "type": "list/index",
              "id": "2.1",
              "outputs": {
                "index": "2.2.a"
              }
            },
            {
              "type": "math/modulus/float",
              "id": "2.2",
              "inputs": {
                "a": "2.1.index",
                "b": 3
              },
              "outputs": {
                "result": "2.3.index"
              }
            },
            {
              "type": "list/get",
              "id": "2.3",
              "inputs": {
                "list": [
                  "red",
                  "green", 
                  "blue"
                ],
                "index": "2.2.result"
              },
              "outputs": {
                "item": "2.OUT"
              }
            }
          ]
        }
      }
    }
  ],
  "outputs": {
    "colors": "2.list"
  }
}
In this example:
  1. The list/generate node creates a list of 10 items.
  2. The list/map spell runs for each item.
  3. Inside the map spell, the list/index node provides the current item index.
  4. The MOD node calculates the remainder of dividing the index by 3 (the number of colors).
  5. The list/get node uses the remainder as the index to select the color from the ["red", "green", "blue"] list.
  6. The map spell outputs the selected color for each item.
The final output will be a list of 10 colors, repeating the red, green, blue pattern: 
["red", "green", "blue", "red", "green", "blue", "red", "green", "blue", "red"]

​
Best Practices

  • Ensure the divisor (b input) is not zero, as division by zero is undefined. You may want to add a is/null check or a default/float node to handle this case gracefully.
  • Keep in mind the MOD node works with floats. If you need integer modulus, round the inputs first or use the math/modulus/integer node instead.

​
Common Issues

  • If the MOD node receives a null or non-numeric input, it will output null. Handle these cases with type checking, default values, or error handling as needed.
  • Remember