# Source code for symforce.logic

```# ----------------------------------------------------------------------------
# SymForce - Copyright 2022, Skydio, Inc.
# This source code is under the Apache 2.0 license found in the LICENSE file.
# ----------------------------------------------------------------------------

"""
Functions for dealing with logical operations represented by scalars
"""

import symforce.internal.symbolic as sf

[docs]def is_positive(x: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x is positive, 0 otherwise
"""
return sf.Max(sf.sign(x), 0)

[docs]def is_negative(x: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x is negative, 0 otherwise
"""
return sf.Max(sf.sign(-x), 0)

[docs]def is_nonnegative(x: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x is >= 0, 0 if x is negative
"""
return 1 - sf.Max(sf.sign(-x), 0)

[docs]def is_nonpositive(x: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x is <= 0, 0 if x is positive
"""
return 1 - sf.Max(sf.sign(x), 0)

[docs]def less_equal(x: sf.Scalar, y: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x <= y, 0 otherwise
"""
return is_nonpositive(x - y)

[docs]def greater_equal(x: sf.Scalar, y: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x >= y, 0 otherwise
"""
return is_nonnegative(x - y)

[docs]def less(x: sf.Scalar, y: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x < y, 0 otherwise
"""
return is_negative(x - y)

[docs]def greater(x: sf.Scalar, y: sf.Scalar) -> sf.Scalar:
"""
Returns 1 if x > y, 0 otherwise
"""
return is_positive(x - y)

[docs]def logical_and(*args: sf.Scalar, unsafe: bool = False) -> sf.Scalar:
"""
Logical and of two or more Scalars

Input values are treated as true if they are positive, false if they are 0 or negative.
The returned value is 1 for true, 0 for false.

If unsafe is True, the resulting expression is fewer ops but assumes the inputs are exactly
0 or 1; results for other (finite) inputs will be finite, but are otherwise undefined.
"""
if unsafe:
return sf.Min(*args)
else:
return sf.Max(sum(sf.sign(x) for x in args), len(args) - 1) - (len(args) - 1)

[docs]def logical_or(*args: sf.Scalar, unsafe: bool = False) -> sf.Scalar:
"""
Logical or of two or more Scalars

Input values are treated as true if they are positive, false if they are 0 or negative.
The returned value is 1 for true, 0 for false.

If unsafe is True, the resulting expression is fewer ops but assumes the inputs are exactly
0 or 1; results for other (finite) inputs will be finite, but are otherwise undefined.
"""
if unsafe:
return sf.Max(*args)
else:
return sf.Max(*[sf.sign(x) for x in args], 0)

[docs]def logical_not(a: sf.Scalar, unsafe: bool = False) -> sf.Scalar:
"""
Logical not of a Scalar

Input value is treated as true if it is positive, false if it is 0 or negative. The
returned value is 1 for true, 0 for false.

If unsafe is True, the resulting expression is fewer ops but assumes the inputs are exactly
0 or 1; results for other (finite) inputs will be finite, but are otherwise undefined.
"""
if unsafe:
return 1 - a
else:
return 1 - sf.Max(sf.sign(a), 0)
```