# Node: Logic

The Logic node allows you to compare two values of Number, Boolean, or String type, or two lists of values of any of those same types. Values being compared of incompatible types will always result in an output of `false`. The way in which comparisons work is slightly different for each of the three supported types.

## Supported Operations

### Booleans

Operation Result
Greater than (lhs > rhs) `true` if only the `lhs` is `true`, otherwise `false`
Greater than or equal to (lhs >= rhs) `true` if the `lhs` is `true`, otherwise `false`
Less than (lhs < rhs) `true` if only the `rhs` is `true`, otherwise `false`
Less than or equal to (lhs <= rhs) `true` if the `rhs` is `true`, otherwise `false`.
Equal to (lhs = rhs) `true` if both `lhs` and `rhs` are `true` or `false`, `false` if `lhs` and `rhs` are different
Not equal to (lhs != rhs) `true` if `lhs` and `rhs` are different, `false` if both `lhs` and `rhs` are equal
Or (lhs | rhs) `true` if either `lhs` or `rhs` are `true`, otherwise `false`
Exclusive or (lhs but not rhs | rhs but not lhs) `true` if only `lhs` or `rhs` is `true`, `false` if both `lhs` and `rhs` are `true` or are both `false`
And (lhs & rhs) `true` if both `lhs` and `rhs` are `true`, otherwise `false`

### Numbers

Operation Result
Greater than (lhs > rhs) `true` if `lhs` is greater than `rhs`, otherwise `false`
Greater than or equal to (lhs >= rhs) `true` if `lhs` is greater than or equal to `rhs`, otherwise `false`
Less than (lhs < rhs) `true` if `lhs` is less than `rhs`, otherwise `false`
Less than or equal to (lhs <= rhs) `true` if `lhs` is less than or equal to `rhs`, otherwise `false`
Equal to (lhs = rhs) `true` if `lhs` is equal to `rhs`, otherwise `false`
Not equal to (lhs != rhs) `true` if `lhs` is not equal to `rhs`, otherwise `false`
Or (lhs | rhs) rounds the `lhs` and `rhs` to the nearest whole number and performs a bitwise or operation
Exclusive or (lhs but not rhs | rhs but not lhs) rounds the `lhs` and `rhs` to the nearest whole number and performs a bitwise xor operation
And (lhs & rhs) rounds the `lhs` and `rhs` to the nearest whole number and performs a bitwise and operation

### Strings

String logic is the most complicated of the three supported types upon which the logic node operates. The normal greater than, less than, equal, and not equal style comparisons are performed by comparing the strings alphabetically, meaning `"Saint"` is greater than `"Bernard"`, but less than `"Waltz"`. The And, Exclusive Or, and Or operations are more complicated and are described in depth below. These three operations are unintuitive, and have no practical purpose, but are implemented here to allow for parity in logic support across all types.

Operation Result
Greater than (lhs > rhs) `true` if `lhs` comes alphabetically after `rhs`, otherwise `false`
Greater than or equal to (lhs >= rhs) `true` if `lhs` comes alphabetically after `rhs` or is the same as `rhs`, otherwise `false`
Less than (lhs < rhs) `true` if `lhs` comes alphabetically before `rhs`, otherwise `false`
Less than or equal to (lhs <= rhs) `true` if `lhs` comes alphabetically before `rhs` or is the same as `rhs`, otherwise `false`
Equal to (lhs = rhs) `true` if `lhs` and `rhs` are the same, otherwise `false`
Not equal to (lhs != rhs) `true` if `lhs` and `rhs` are not the same, otherwise `false`
Or (lhs | rhs) a new String in which each character from `lhs` and `rhs` are converted to a Number, a bitwise or operation are performed on those numbers to produce a new number, and the new number is converted back to a character in the new String result
Exclusive or (lhs but not rhs | rhs but not lhs) a new String in which each character from `lhs` and `rhs` are converted to a Number, a bitwise xor operation are performed on those numbers to produce a new number, and the new number is converted back to a character in the new String result
And (lhs & rhs) a new String in which each character from `lhs` and `rhs` are converted to a Number, a bitwise and operation are performed on those numbers to produce a new number, and the new number is converted back to a character in the new String result

### Nulls

When a Null value is provided to both the `lhs` and `rhs` of any logic operation, the result will always be `true`.

Operation Result
Greater than (lhs > rhs) `true`
Greater than or equal to (lhs >= rhs) `true`
Less than (lhs < rhs) `true`
Less than or equal to (lhs <= rhs) `true`
Equal to (lhs = rhs) `true`
Not equal to (lhs != rhs) `true`
Or (lhs | rhs) `true`
Exclusive or (lhs but not rhs | rhs but not lhs) `true`
And (lhs & rhs) `true`

### Non-comparable Values

When the `lhs` and `rhs` can not be compared (for example when the `lhs` is a String and the `rhs` is a Number), the result will be `false`, with the exception of the `Not equal to` operation, which will produce `true` as its result.

Operation Result
Greater than (lhs > rhs) `false`
Greater than or equal to (lhs >= rhs) `false`
Less than (lhs < rhs) `false`
Less than or equal to (lhs <= rhs) `false`
Equal to (lhs = rhs) `false`
Not equal to (lhs != rhs) `true`
Or (lhs | rhs) `false`
Exclusive or (lhs but not rhs | rhs but not lhs) `false`
And (lhs & rhs) `false`

## Handling Nulls

While the Supported Operations section covered what happens when both `lhs` and `rhs` are Null values, a special behavior is in place when only the `lhs` or `rhs` are Null and the other side is of a supported type. In these situations, a new value is substituted for the Null in order to better facilitate comparisons with what are considered the types equivalents of Null.

Replacement for Null
Number `0`
Boolean `false`
String `""`

## Settings

Expected Type Details Default
`lhs` List<Boolean, Number, or String> The left hand side of the logic operation. This list can contain a mix of the supported types. Unsupported types are treated as Null values.
`operation` LogicOperation The operation to be performed on the lhs and rhs lists. This value can be changed externally by assigning `\$.logic.operation = Packages.com.worldstage.waltz.nodes.LogicOperatorNode.LogicOperation.LessThan` or similar. `Equal to (lhs = rhs)`
`rhs` List<Boolean, Number, or String> The right hand side of the logic operation. This list can contain a mix of the supported types. Unsupported types are treated as Null values.

## Parameters

Type Details
`output` Any or List<Any> Note: The parameter is read-only. The logical output of the selected `operation`, applied to the `lhs` and `rhs`. This result is a List if either `lhs` or `rhs` contained more than one item.

## Functions

There are no functions exposed by this node.

## Example Usage

No examples provided.

Nodes
Devices ArtNet Input · ArtNet Output · Interactive LED Processor · NDI™ Input · NDI™ Output · OSC Input · OSC Output · Projector · SensorLink · TCP · TUIO Output · UDP Input · UDP Output · Watchout Media Server
Objects LED Tile Layout · List · Map · Random Number · Simulated Touch · Timer · Value · Wave
Operators Blend · Change · Clip · Cluster Tracker · DMX Multiverse Merge · Ease · Filter · Hold · JSON Mapper · JSON Stringify · Logic · Math · Proximity · Range · Rotate · Scale · Shear · Smooth · Touch Mapper · Translate
Scenes External Scene · Material Scene
Materials Graph · Touch Material
Scripting Script Function · Script