### Introduction

This tutorial will explain the use of relational and logical operators in GAUSS.

## Matrix relational operators

- Return a scalar 1 if the statement is true for every element in the matrix, otherwise a 0.

Operator | Purpose |
---|---|

== | Equality |

> | Greater than |

>= | Greater than or equal |

< | Less than |

<= | Less than or equal |

!= | Not equal |

### Scalar equality

```
a = 0.7;
// Set 'c1' equal to 1 if
// 'a' is greater than 0.5
c1 = a > 0.5;
// Set 'c2' equal to 1 if
// 'a' is less than 0.5
c2 = a < 0.5;
```

will assign

c1 = 1 c2 = 0

### Matrix inequality

In our first example, the variable `a`

had only one element. Let's look at a matrix example.

```
// Create a 2x3 matrix
a = { 0.1 0.5 0.4,
0.5 0.3 0.7 };
// Assign 'c1' to equal 1 if EVERY
// element of 'a' is > 0.4;
c1 = a > 0.4;
// Assign 'c2' to equal 1 if EVERY
// element of 'a' is < 0.8;
c2 = a < 0.8;
```

will assign

c1 = 0 c2 = 1

This time, `c1`

will be set equal to `0`

, because several of the elements of `a`

are less than 0.4.

Whereas `c2`

will be set equal to `1`

, because *every* element of `a`

is less than 0.8.

### Matrix equality

```
// Create a 2x3 matrix
a = { 0.1 0.5 0.4,
0.5 0.3 0.7 };
// Assign 'c1' to equal 1 if EVERY
// element of 'a' is equal 0.4;
c1 = a == 0.4;
// Assign 'c2' to equal 1 if EVERY
// element of 'a' does NOT equal 0.4
c2 = a != 0.4;
// Assign 'c3' to equal 1 if EVERY
// element of 'a' does NOT equal 0.8
c3 = a != 0.8;
```

After the code above:

c1 = 0 c2 = 0 c3 = 1

## Element‐by‐element relational operators

- Return a matrix or vector of 1's and 0's with a 1 at the location of the elements for which the operator returns true and a 0 for the other elements.

Operator | Purpose |
---|---|

.== | Equality |

.> | Greater than |

.>= | Greater than or equal |

.< | Less than |

.<= | Less than or equal |

.!= | Not equal |

### Matrix element‐by‐element inequality

The scalar case is the same as for the matrix operators, so we will start with a matrix example.

```
// Create a 2x3 matrix
a = { 0.1 0.5 0.4,
0.5 0.3 0.7 };
// Return a 2x3 matrix of 1's
// and 0's indicating whether the
// corresponding element of 'a'
// is > 0.4
c1 = a .> 0.4;
// Return a 2x3 matrix of 1's
// and 0's indicating whether the
// corresponding element of 'a'
// is ≤ 0.5
c2 = a .<= 0.5;
```

After the above code

c1 = 0 1 0 1 0 1 c2 = 1 1 1 1 1 0

## ExE conformability

The ExE conformability of the GAUSS relational operators makes it simple make comparisons along rows or columns.

### Column inequality

```
// Create a 4x2 matrix
a = { 125 23,
150 31,
105 19,
150 33 };
// Create a 1x2 row vector
b = { 120 25 };
// Check which elements in the first column of 'a'
// are greater than the first element of 'b',
// and which elements of the second column of 'a'
// are greater than the second element of 'b'
c = a .> b;
```

The above code will assign:

c = 1 0 1 1 0 0 1 1

### Row inequality

```
// Create a 4x2 matrix
a = { 25 23,
50 31,
5 19,
41 33 };
// Create a 4x1 column vector
b = { 23,
31,
10,
50 };
// Check which elements in the rows of 'a'
// are less than or equal to the elements of the
// corresponding row of 'b'
c = a .<= b;
```

The above code will assign:

c = 0 1 0 1 1 0 1 1

## Scalar logical operators

Operator | Purpose |
---|---|

and | Tests whether two scalars are both non‐zero |

or | Tests whether at least one of two scalars is non‐zero |

not | Tests whether a statement is zero |

### Scalar 'and'

```
a = 1;
b = 9;
x = 0;
// Are both 'a' and 'b' non-zero?
c1 = a and b;
// Are both 'x' and 'a' non-zero?
c2 = x and a;
// Are both 'b' and 0 non-zero?
c3 = b and 0;
```

will assign

c1 = 1 c2 = 0 c3 = 0

### Scalar 'or'

```
a = 1;
b = 9;
x = 0;
// Is either 'a' or 'b', or both, non-zero?
c1 = a or b;
// Is either 'x' or 'a', or both, non-zero?
c2 = x or a;
// Is either 'x' or 0, or both, non-zero?
c3 = x or 0;
```

will assign

c1 = 1 c2 = 1 c3 = 0

### Scalar 'not'

```
a = 1;
b = 9;
x = 0;
// Is 'a' zero?
c1 = not a;
// Is 'x' zero?
c2 = not x;
// Does the expression (a and b) return zero?
c3 = not (a and b);
```

will assign

c1 = 0 c2 = 1 c3 = 0

## Element-by-element logical operators

Operator | Purpose |
---|---|

.and | Tests whether the corresponding elements of two matrices or vectors are both non‐zero |

.or | Tests whether at least one of the corresponding elements of two matrices or vectors is non‐zero |

.not | Tests whether each element of a matrix is zero |

### Element-by-element '.and'

Matrix and scalar case.

```
a = { 1 2,
3 0 };
b = 9;
x = 0;
// Are both 'a' and 'b' non-zero?
c1 = a .and b;
// Are both 'a' and 'x' non-zero?
c2 = a .and x;
```

will assign

c1 = 1 1 1 0 c2 = 0 0 0 0

Matrix and matrix case.

```
a = { 1 2,
3 0 };
b = { 9 0,
1 1 };
// Are both 'a' and 'b' non-zero?
c1 = a .and b;
```

will assign

c1 = 1 0 1 0

Matrix and row vector case.

```
// 2x3 matrix
a = { 1 0 8,
0 3 1 };
// 1x3 row vector
b = { 9 0 1 };
// Are the corresponding elements of 'a' and 'b' non-zero?
c1 = a .and b;
```

will assign

c1 = 1 0 1 0 0 1

Matrix and column vector case.

```
// 3x3 matrix
a = { 1 0 8,
0 3 1,
1 1 0 };
// 3x1 column vector
b = { 2,
1,
0 };
// Are the corresponding elements of 'a' and 'b' non-zero?
c1 = a .and b;
```

will assign

c1 = 1 0 1 0 1 1 0 0 0

### Element-by-element '.or'

Matrix and scalar case.

```
a = { 1 2,
3 0 };
b = 9;
x = 0;
// Are the elements of either 'a' or 'b', or both, non-zero?
c1 = a .or b;
// Are the elements of either 'a' or 'x', or both, non-zero?
c2 = a .or x;
```

will assign

c1 = 1 1 1 1 c2 = 1 1 1 0

Matrix and matrix case.

```
a = { 1 2,
3 0 };
b = { 9 0,
1 1 };
// Are the elements of either 'a' or 'b', or both, non-zero?
c1 = a .or b;
```

will assign

c1 = 1 1 1 1

Matrix and row vector case.

```
// 2x3 matrix
a = { 1 0 8,
0 3 1 };
// 1x3 row vector
b = { 9 0 1 };
// Are the corresponding elements of either
// 'a' or 'b', or both, non-zero?
c1 = a .or b;
```

will assign

c1 = 1 0 1 1 1 1

Matrix and column vector case.

```
// 3x3 matrix
a = { 1 0 8,
0 3 1,
1 1 0 };
// 3x1 column vector
b = { 2,
1,
0 };
// Are the corresponding elements of either
// 'a' or 'b', or both, non-zero?
c1 = a .or b;
```

will assign

c1 = 1 1 1 1 1 1 1 1 0

### Element-by-element '.not'

```
a = { 4 6,
1 0,
8 2 };
// Are the elements of 'a' zero?
c1 = .not a;
```

will assign

c1 = 0 0 0 1 0 0