# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

"""
Expr module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_expr.html
"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _Expr
else:
    import _Expr

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Expr.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        return _Expr.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _Expr.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _Expr.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _Expr.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _Expr.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _Expr.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _Expr.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _Expr.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _Expr.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _Expr.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _Expr.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _Expr.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Expr.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Expr.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _Expr.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _Expr.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _Expr:
_Expr.SwigPyIterator_swigregister(SwigPyIterator)


def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    return _Expr.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.TColStd
import OCC.Core.TCollection

from enum import IntEnum
from OCC.Core.Exception import *




def Handle_Expr_GeneralExpression_Create() -> "opencascade::handle< Expr_GeneralExpression >":
    return _Expr.Handle_Expr_GeneralExpression_Create()

def Handle_Expr_GeneralExpression_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_GeneralExpression >":
    return _Expr.Handle_Expr_GeneralExpression_DownCast(t)

def Handle_Expr_GeneralExpression_IsNull(t: "opencascade::handle< Expr_GeneralExpression > const &") -> "bool":
    return _Expr.Handle_Expr_GeneralExpression_IsNull(t)

def Handle_Expr_GeneralFunction_Create() -> "opencascade::handle< Expr_GeneralFunction >":
    return _Expr.Handle_Expr_GeneralFunction_Create()

def Handle_Expr_GeneralFunction_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_GeneralFunction >":
    return _Expr.Handle_Expr_GeneralFunction_DownCast(t)

def Handle_Expr_GeneralFunction_IsNull(t: "opencascade::handle< Expr_GeneralFunction > const &") -> "bool":
    return _Expr.Handle_Expr_GeneralFunction_IsNull(t)

def Handle_Expr_GeneralRelation_Create() -> "opencascade::handle< Expr_GeneralRelation >":
    return _Expr.Handle_Expr_GeneralRelation_Create()

def Handle_Expr_GeneralRelation_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_GeneralRelation >":
    return _Expr.Handle_Expr_GeneralRelation_DownCast(t)

def Handle_Expr_GeneralRelation_IsNull(t: "opencascade::handle< Expr_GeneralRelation > const &") -> "bool":
    return _Expr.Handle_Expr_GeneralRelation_IsNull(t)

def Handle_Expr_BinaryExpression_Create() -> "opencascade::handle< Expr_BinaryExpression >":
    return _Expr.Handle_Expr_BinaryExpression_Create()

def Handle_Expr_BinaryExpression_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_BinaryExpression >":
    return _Expr.Handle_Expr_BinaryExpression_DownCast(t)

def Handle_Expr_BinaryExpression_IsNull(t: "opencascade::handle< Expr_BinaryExpression > const &") -> "bool":
    return _Expr.Handle_Expr_BinaryExpression_IsNull(t)

def Handle_Expr_FunctionDerivative_Create() -> "opencascade::handle< Expr_FunctionDerivative >":
    return _Expr.Handle_Expr_FunctionDerivative_Create()

def Handle_Expr_FunctionDerivative_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_FunctionDerivative >":
    return _Expr.Handle_Expr_FunctionDerivative_DownCast(t)

def Handle_Expr_FunctionDerivative_IsNull(t: "opencascade::handle< Expr_FunctionDerivative > const &") -> "bool":
    return _Expr.Handle_Expr_FunctionDerivative_IsNull(t)

def Handle_Expr_NamedExpression_Create() -> "opencascade::handle< Expr_NamedExpression >":
    return _Expr.Handle_Expr_NamedExpression_Create()

def Handle_Expr_NamedExpression_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_NamedExpression >":
    return _Expr.Handle_Expr_NamedExpression_DownCast(t)

def Handle_Expr_NamedExpression_IsNull(t: "opencascade::handle< Expr_NamedExpression > const &") -> "bool":
    return _Expr.Handle_Expr_NamedExpression_IsNull(t)

def Handle_Expr_NamedFunction_Create() -> "opencascade::handle< Expr_NamedFunction >":
    return _Expr.Handle_Expr_NamedFunction_Create()

def Handle_Expr_NamedFunction_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_NamedFunction >":
    return _Expr.Handle_Expr_NamedFunction_DownCast(t)

def Handle_Expr_NamedFunction_IsNull(t: "opencascade::handle< Expr_NamedFunction > const &") -> "bool":
    return _Expr.Handle_Expr_NamedFunction_IsNull(t)

def Handle_Expr_NumericValue_Create() -> "opencascade::handle< Expr_NumericValue >":
    return _Expr.Handle_Expr_NumericValue_Create()

def Handle_Expr_NumericValue_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_NumericValue >":
    return _Expr.Handle_Expr_NumericValue_DownCast(t)

def Handle_Expr_NumericValue_IsNull(t: "opencascade::handle< Expr_NumericValue > const &") -> "bool":
    return _Expr.Handle_Expr_NumericValue_IsNull(t)

def Handle_Expr_PolyExpression_Create() -> "opencascade::handle< Expr_PolyExpression >":
    return _Expr.Handle_Expr_PolyExpression_Create()

def Handle_Expr_PolyExpression_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_PolyExpression >":
    return _Expr.Handle_Expr_PolyExpression_DownCast(t)

def Handle_Expr_PolyExpression_IsNull(t: "opencascade::handle< Expr_PolyExpression > const &") -> "bool":
    return _Expr.Handle_Expr_PolyExpression_IsNull(t)

def Handle_Expr_SingleRelation_Create() -> "opencascade::handle< Expr_SingleRelation >":
    return _Expr.Handle_Expr_SingleRelation_Create()

def Handle_Expr_SingleRelation_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_SingleRelation >":
    return _Expr.Handle_Expr_SingleRelation_DownCast(t)

def Handle_Expr_SingleRelation_IsNull(t: "opencascade::handle< Expr_SingleRelation > const &") -> "bool":
    return _Expr.Handle_Expr_SingleRelation_IsNull(t)

def Handle_Expr_SystemRelation_Create() -> "opencascade::handle< Expr_SystemRelation >":
    return _Expr.Handle_Expr_SystemRelation_Create()

def Handle_Expr_SystemRelation_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_SystemRelation >":
    return _Expr.Handle_Expr_SystemRelation_DownCast(t)

def Handle_Expr_SystemRelation_IsNull(t: "opencascade::handle< Expr_SystemRelation > const &") -> "bool":
    return _Expr.Handle_Expr_SystemRelation_IsNull(t)

def Handle_Expr_UnaryExpression_Create() -> "opencascade::handle< Expr_UnaryExpression >":
    return _Expr.Handle_Expr_UnaryExpression_Create()

def Handle_Expr_UnaryExpression_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_UnaryExpression >":
    return _Expr.Handle_Expr_UnaryExpression_DownCast(t)

def Handle_Expr_UnaryExpression_IsNull(t: "opencascade::handle< Expr_UnaryExpression > const &") -> "bool":
    return _Expr.Handle_Expr_UnaryExpression_IsNull(t)

def Handle_Expr_Absolute_Create() -> "opencascade::handle< Expr_Absolute >":
    return _Expr.Handle_Expr_Absolute_Create()

def Handle_Expr_Absolute_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Absolute >":
    return _Expr.Handle_Expr_Absolute_DownCast(t)

def Handle_Expr_Absolute_IsNull(t: "opencascade::handle< Expr_Absolute > const &") -> "bool":
    return _Expr.Handle_Expr_Absolute_IsNull(t)

def Handle_Expr_ArcCosine_Create() -> "opencascade::handle< Expr_ArcCosine >":
    return _Expr.Handle_Expr_ArcCosine_Create()

def Handle_Expr_ArcCosine_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArcCosine >":
    return _Expr.Handle_Expr_ArcCosine_DownCast(t)

def Handle_Expr_ArcCosine_IsNull(t: "opencascade::handle< Expr_ArcCosine > const &") -> "bool":
    return _Expr.Handle_Expr_ArcCosine_IsNull(t)

def Handle_Expr_ArcSine_Create() -> "opencascade::handle< Expr_ArcSine >":
    return _Expr.Handle_Expr_ArcSine_Create()

def Handle_Expr_ArcSine_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArcSine >":
    return _Expr.Handle_Expr_ArcSine_DownCast(t)

def Handle_Expr_ArcSine_IsNull(t: "opencascade::handle< Expr_ArcSine > const &") -> "bool":
    return _Expr.Handle_Expr_ArcSine_IsNull(t)

def Handle_Expr_ArcTangent_Create() -> "opencascade::handle< Expr_ArcTangent >":
    return _Expr.Handle_Expr_ArcTangent_Create()

def Handle_Expr_ArcTangent_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArcTangent >":
    return _Expr.Handle_Expr_ArcTangent_DownCast(t)

def Handle_Expr_ArcTangent_IsNull(t: "opencascade::handle< Expr_ArcTangent > const &") -> "bool":
    return _Expr.Handle_Expr_ArcTangent_IsNull(t)

def Handle_Expr_ArgCosh_Create() -> "opencascade::handle< Expr_ArgCosh >":
    return _Expr.Handle_Expr_ArgCosh_Create()

def Handle_Expr_ArgCosh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArgCosh >":
    return _Expr.Handle_Expr_ArgCosh_DownCast(t)

def Handle_Expr_ArgCosh_IsNull(t: "opencascade::handle< Expr_ArgCosh > const &") -> "bool":
    return _Expr.Handle_Expr_ArgCosh_IsNull(t)

def Handle_Expr_ArgSinh_Create() -> "opencascade::handle< Expr_ArgSinh >":
    return _Expr.Handle_Expr_ArgSinh_Create()

def Handle_Expr_ArgSinh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArgSinh >":
    return _Expr.Handle_Expr_ArgSinh_DownCast(t)

def Handle_Expr_ArgSinh_IsNull(t: "opencascade::handle< Expr_ArgSinh > const &") -> "bool":
    return _Expr.Handle_Expr_ArgSinh_IsNull(t)

def Handle_Expr_ArgTanh_Create() -> "opencascade::handle< Expr_ArgTanh >":
    return _Expr.Handle_Expr_ArgTanh_Create()

def Handle_Expr_ArgTanh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_ArgTanh >":
    return _Expr.Handle_Expr_ArgTanh_DownCast(t)

def Handle_Expr_ArgTanh_IsNull(t: "opencascade::handle< Expr_ArgTanh > const &") -> "bool":
    return _Expr.Handle_Expr_ArgTanh_IsNull(t)

def Handle_Expr_BinaryFunction_Create() -> "opencascade::handle< Expr_BinaryFunction >":
    return _Expr.Handle_Expr_BinaryFunction_Create()

def Handle_Expr_BinaryFunction_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_BinaryFunction >":
    return _Expr.Handle_Expr_BinaryFunction_DownCast(t)

def Handle_Expr_BinaryFunction_IsNull(t: "opencascade::handle< Expr_BinaryFunction > const &") -> "bool":
    return _Expr.Handle_Expr_BinaryFunction_IsNull(t)

def Handle_Expr_Cosh_Create() -> "opencascade::handle< Expr_Cosh >":
    return _Expr.Handle_Expr_Cosh_Create()

def Handle_Expr_Cosh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Cosh >":
    return _Expr.Handle_Expr_Cosh_DownCast(t)

def Handle_Expr_Cosh_IsNull(t: "opencascade::handle< Expr_Cosh > const &") -> "bool":
    return _Expr.Handle_Expr_Cosh_IsNull(t)

def Handle_Expr_Cosine_Create() -> "opencascade::handle< Expr_Cosine >":
    return _Expr.Handle_Expr_Cosine_Create()

def Handle_Expr_Cosine_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Cosine >":
    return _Expr.Handle_Expr_Cosine_DownCast(t)

def Handle_Expr_Cosine_IsNull(t: "opencascade::handle< Expr_Cosine > const &") -> "bool":
    return _Expr.Handle_Expr_Cosine_IsNull(t)

def Handle_Expr_Difference_Create() -> "opencascade::handle< Expr_Difference >":
    return _Expr.Handle_Expr_Difference_Create()

def Handle_Expr_Difference_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Difference >":
    return _Expr.Handle_Expr_Difference_DownCast(t)

def Handle_Expr_Difference_IsNull(t: "opencascade::handle< Expr_Difference > const &") -> "bool":
    return _Expr.Handle_Expr_Difference_IsNull(t)

def Handle_Expr_Different_Create() -> "opencascade::handle< Expr_Different >":
    return _Expr.Handle_Expr_Different_Create()

def Handle_Expr_Different_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Different >":
    return _Expr.Handle_Expr_Different_DownCast(t)

def Handle_Expr_Different_IsNull(t: "opencascade::handle< Expr_Different > const &") -> "bool":
    return _Expr.Handle_Expr_Different_IsNull(t)

def Handle_Expr_Division_Create() -> "opencascade::handle< Expr_Division >":
    return _Expr.Handle_Expr_Division_Create()

def Handle_Expr_Division_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Division >":
    return _Expr.Handle_Expr_Division_DownCast(t)

def Handle_Expr_Division_IsNull(t: "opencascade::handle< Expr_Division > const &") -> "bool":
    return _Expr.Handle_Expr_Division_IsNull(t)

def Handle_Expr_Equal_Create() -> "opencascade::handle< Expr_Equal >":
    return _Expr.Handle_Expr_Equal_Create()

def Handle_Expr_Equal_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Equal >":
    return _Expr.Handle_Expr_Equal_DownCast(t)

def Handle_Expr_Equal_IsNull(t: "opencascade::handle< Expr_Equal > const &") -> "bool":
    return _Expr.Handle_Expr_Equal_IsNull(t)

def Handle_Expr_Exponential_Create() -> "opencascade::handle< Expr_Exponential >":
    return _Expr.Handle_Expr_Exponential_Create()

def Handle_Expr_Exponential_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Exponential >":
    return _Expr.Handle_Expr_Exponential_DownCast(t)

def Handle_Expr_Exponential_IsNull(t: "opencascade::handle< Expr_Exponential > const &") -> "bool":
    return _Expr.Handle_Expr_Exponential_IsNull(t)

def Handle_Expr_Exponentiate_Create() -> "opencascade::handle< Expr_Exponentiate >":
    return _Expr.Handle_Expr_Exponentiate_Create()

def Handle_Expr_Exponentiate_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Exponentiate >":
    return _Expr.Handle_Expr_Exponentiate_DownCast(t)

def Handle_Expr_Exponentiate_IsNull(t: "opencascade::handle< Expr_Exponentiate > const &") -> "bool":
    return _Expr.Handle_Expr_Exponentiate_IsNull(t)

def Handle_Expr_GreaterThan_Create() -> "opencascade::handle< Expr_GreaterThan >":
    return _Expr.Handle_Expr_GreaterThan_Create()

def Handle_Expr_GreaterThan_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_GreaterThan >":
    return _Expr.Handle_Expr_GreaterThan_DownCast(t)

def Handle_Expr_GreaterThan_IsNull(t: "opencascade::handle< Expr_GreaterThan > const &") -> "bool":
    return _Expr.Handle_Expr_GreaterThan_IsNull(t)

def Handle_Expr_GreaterThanOrEqual_Create() -> "opencascade::handle< Expr_GreaterThanOrEqual >":
    return _Expr.Handle_Expr_GreaterThanOrEqual_Create()

def Handle_Expr_GreaterThanOrEqual_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_GreaterThanOrEqual >":
    return _Expr.Handle_Expr_GreaterThanOrEqual_DownCast(t)

def Handle_Expr_GreaterThanOrEqual_IsNull(t: "opencascade::handle< Expr_GreaterThanOrEqual > const &") -> "bool":
    return _Expr.Handle_Expr_GreaterThanOrEqual_IsNull(t)

def Handle_Expr_LessThan_Create() -> "opencascade::handle< Expr_LessThan >":
    return _Expr.Handle_Expr_LessThan_Create()

def Handle_Expr_LessThan_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_LessThan >":
    return _Expr.Handle_Expr_LessThan_DownCast(t)

def Handle_Expr_LessThan_IsNull(t: "opencascade::handle< Expr_LessThan > const &") -> "bool":
    return _Expr.Handle_Expr_LessThan_IsNull(t)

def Handle_Expr_LessThanOrEqual_Create() -> "opencascade::handle< Expr_LessThanOrEqual >":
    return _Expr.Handle_Expr_LessThanOrEqual_Create()

def Handle_Expr_LessThanOrEqual_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_LessThanOrEqual >":
    return _Expr.Handle_Expr_LessThanOrEqual_DownCast(t)

def Handle_Expr_LessThanOrEqual_IsNull(t: "opencascade::handle< Expr_LessThanOrEqual > const &") -> "bool":
    return _Expr.Handle_Expr_LessThanOrEqual_IsNull(t)

def Handle_Expr_LogOf10_Create() -> "opencascade::handle< Expr_LogOf10 >":
    return _Expr.Handle_Expr_LogOf10_Create()

def Handle_Expr_LogOf10_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_LogOf10 >":
    return _Expr.Handle_Expr_LogOf10_DownCast(t)

def Handle_Expr_LogOf10_IsNull(t: "opencascade::handle< Expr_LogOf10 > const &") -> "bool":
    return _Expr.Handle_Expr_LogOf10_IsNull(t)

def Handle_Expr_LogOfe_Create() -> "opencascade::handle< Expr_LogOfe >":
    return _Expr.Handle_Expr_LogOfe_Create()

def Handle_Expr_LogOfe_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_LogOfe >":
    return _Expr.Handle_Expr_LogOfe_DownCast(t)

def Handle_Expr_LogOfe_IsNull(t: "opencascade::handle< Expr_LogOfe > const &") -> "bool":
    return _Expr.Handle_Expr_LogOfe_IsNull(t)

def Handle_Expr_NamedConstant_Create() -> "opencascade::handle< Expr_NamedConstant >":
    return _Expr.Handle_Expr_NamedConstant_Create()

def Handle_Expr_NamedConstant_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_NamedConstant >":
    return _Expr.Handle_Expr_NamedConstant_DownCast(t)

def Handle_Expr_NamedConstant_IsNull(t: "opencascade::handle< Expr_NamedConstant > const &") -> "bool":
    return _Expr.Handle_Expr_NamedConstant_IsNull(t)

def Handle_Expr_NamedUnknown_Create() -> "opencascade::handle< Expr_NamedUnknown >":
    return _Expr.Handle_Expr_NamedUnknown_Create()

def Handle_Expr_NamedUnknown_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_NamedUnknown >":
    return _Expr.Handle_Expr_NamedUnknown_DownCast(t)

def Handle_Expr_NamedUnknown_IsNull(t: "opencascade::handle< Expr_NamedUnknown > const &") -> "bool":
    return _Expr.Handle_Expr_NamedUnknown_IsNull(t)

def Handle_Expr_PolyFunction_Create() -> "opencascade::handle< Expr_PolyFunction >":
    return _Expr.Handle_Expr_PolyFunction_Create()

def Handle_Expr_PolyFunction_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_PolyFunction >":
    return _Expr.Handle_Expr_PolyFunction_DownCast(t)

def Handle_Expr_PolyFunction_IsNull(t: "opencascade::handle< Expr_PolyFunction > const &") -> "bool":
    return _Expr.Handle_Expr_PolyFunction_IsNull(t)

def Handle_Expr_Product_Create() -> "opencascade::handle< Expr_Product >":
    return _Expr.Handle_Expr_Product_Create()

def Handle_Expr_Product_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Product >":
    return _Expr.Handle_Expr_Product_DownCast(t)

def Handle_Expr_Product_IsNull(t: "opencascade::handle< Expr_Product > const &") -> "bool":
    return _Expr.Handle_Expr_Product_IsNull(t)

def Handle_Expr_Sine_Create() -> "opencascade::handle< Expr_Sine >":
    return _Expr.Handle_Expr_Sine_Create()

def Handle_Expr_Sine_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Sine >":
    return _Expr.Handle_Expr_Sine_DownCast(t)

def Handle_Expr_Sine_IsNull(t: "opencascade::handle< Expr_Sine > const &") -> "bool":
    return _Expr.Handle_Expr_Sine_IsNull(t)

def Handle_Expr_Sinh_Create() -> "opencascade::handle< Expr_Sinh >":
    return _Expr.Handle_Expr_Sinh_Create()

def Handle_Expr_Sinh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Sinh >":
    return _Expr.Handle_Expr_Sinh_DownCast(t)

def Handle_Expr_Sinh_IsNull(t: "opencascade::handle< Expr_Sinh > const &") -> "bool":
    return _Expr.Handle_Expr_Sinh_IsNull(t)

def Handle_Expr_Square_Create() -> "opencascade::handle< Expr_Square >":
    return _Expr.Handle_Expr_Square_Create()

def Handle_Expr_Square_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Square >":
    return _Expr.Handle_Expr_Square_DownCast(t)

def Handle_Expr_Square_IsNull(t: "opencascade::handle< Expr_Square > const &") -> "bool":
    return _Expr.Handle_Expr_Square_IsNull(t)

def Handle_Expr_SquareRoot_Create() -> "opencascade::handle< Expr_SquareRoot >":
    return _Expr.Handle_Expr_SquareRoot_Create()

def Handle_Expr_SquareRoot_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_SquareRoot >":
    return _Expr.Handle_Expr_SquareRoot_DownCast(t)

def Handle_Expr_SquareRoot_IsNull(t: "opencascade::handle< Expr_SquareRoot > const &") -> "bool":
    return _Expr.Handle_Expr_SquareRoot_IsNull(t)

def Handle_Expr_Sum_Create() -> "opencascade::handle< Expr_Sum >":
    return _Expr.Handle_Expr_Sum_Create()

def Handle_Expr_Sum_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Sum >":
    return _Expr.Handle_Expr_Sum_DownCast(t)

def Handle_Expr_Sum_IsNull(t: "opencascade::handle< Expr_Sum > const &") -> "bool":
    return _Expr.Handle_Expr_Sum_IsNull(t)

def Handle_Expr_Tangent_Create() -> "opencascade::handle< Expr_Tangent >":
    return _Expr.Handle_Expr_Tangent_Create()

def Handle_Expr_Tangent_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Tangent >":
    return _Expr.Handle_Expr_Tangent_DownCast(t)

def Handle_Expr_Tangent_IsNull(t: "opencascade::handle< Expr_Tangent > const &") -> "bool":
    return _Expr.Handle_Expr_Tangent_IsNull(t)

def Handle_Expr_Tanh_Create() -> "opencascade::handle< Expr_Tanh >":
    return _Expr.Handle_Expr_Tanh_Create()

def Handle_Expr_Tanh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_Tanh >":
    return _Expr.Handle_Expr_Tanh_DownCast(t)

def Handle_Expr_Tanh_IsNull(t: "opencascade::handle< Expr_Tanh > const &") -> "bool":
    return _Expr.Handle_Expr_Tanh_IsNull(t)

def Handle_Expr_UnaryFunction_Create() -> "opencascade::handle< Expr_UnaryFunction >":
    return _Expr.Handle_Expr_UnaryFunction_Create()

def Handle_Expr_UnaryFunction_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_UnaryFunction >":
    return _Expr.Handle_Expr_UnaryFunction_DownCast(t)

def Handle_Expr_UnaryFunction_IsNull(t: "opencascade::handle< Expr_UnaryFunction > const &") -> "bool":
    return _Expr.Handle_Expr_UnaryFunction_IsNull(t)

def Handle_Expr_UnaryMinus_Create() -> "opencascade::handle< Expr_UnaryMinus >":
    return _Expr.Handle_Expr_UnaryMinus_Create()

def Handle_Expr_UnaryMinus_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< Expr_UnaryMinus >":
    return _Expr.Handle_Expr_UnaryMinus_DownCast(t)

def Handle_Expr_UnaryMinus_IsNull(t: "opencascade::handle< Expr_UnaryMinus > const &") -> "bool":
    return _Expr.Handle_Expr_UnaryMinus_IsNull(t)
class Expr_Array1OfGeneralExpression(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > >::iterator":
        return _Expr.Expr_Array1OfGeneralExpression_begin(self)

    def end(self) -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > >::iterator":
        return _Expr.Expr_Array1OfGeneralExpression_end(self)

    def cbegin(self) -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > >::const_iterator":
        return _Expr.Expr_Array1OfGeneralExpression_cbegin(self)

    def cend(self) -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > >::const_iterator":
        return _Expr.Expr_Array1OfGeneralExpression_cend(self)

    def __init__(self, *args):
        _Expr.Expr_Array1OfGeneralExpression_swiginit(self, _Expr.new_Expr_Array1OfGeneralExpression(*args))

    def Init(self, theValue: "opencascade::handle< Expr_GeneralExpression > const &") -> "void":
        return _Expr.Expr_Array1OfGeneralExpression_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfGeneralExpression_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfGeneralExpression_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfGeneralExpression_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfGeneralExpression_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfGeneralExpression_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfGeneralExpression_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfGeneralExpression_IsAllocated(self)

    def Assign(self, theOther: "Expr_Array1OfGeneralExpression") -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > > &":
        return _Expr.Expr_Array1OfGeneralExpression_Assign(self, theOther)

    def Move(self, theOther: "Expr_Array1OfGeneralExpression") -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > > &":
        return _Expr.Expr_Array1OfGeneralExpression_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< opencascade::handle< Expr_GeneralExpression > > &":
        return _Expr.Expr_Array1OfGeneralExpression_Set(self, *args)

    def First(self) -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_Array1OfGeneralExpression_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_Array1OfGeneralExpression_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_Array1OfGeneralExpression_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_Array1OfGeneralExpression_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_Array1OfGeneralExpression_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_Array1OfGeneralExpression_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_Array1OfGeneralExpression___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Expr_GeneralExpression > const &") -> "void":
        return _Expr.Expr_Array1OfGeneralExpression_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _Expr.Expr_Array1OfGeneralExpression_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _Expr.delete_Expr_Array1OfGeneralExpression

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register Expr_Array1OfGeneralExpression in _Expr:
_Expr.Expr_Array1OfGeneralExpression_swigregister(Expr_Array1OfGeneralExpression)

class Expr_Array1OfNamedUnknown(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > >::iterator":
        return _Expr.Expr_Array1OfNamedUnknown_begin(self)

    def end(self) -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > >::iterator":
        return _Expr.Expr_Array1OfNamedUnknown_end(self)

    def cbegin(self) -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > >::const_iterator":
        return _Expr.Expr_Array1OfNamedUnknown_cbegin(self)

    def cend(self) -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > >::const_iterator":
        return _Expr.Expr_Array1OfNamedUnknown_cend(self)

    def __init__(self, *args):
        _Expr.Expr_Array1OfNamedUnknown_swiginit(self, _Expr.new_Expr_Array1OfNamedUnknown(*args))

    def Init(self, theValue: "opencascade::handle< Expr_NamedUnknown > const &") -> "void":
        return _Expr.Expr_Array1OfNamedUnknown_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfNamedUnknown_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfNamedUnknown_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfNamedUnknown_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfNamedUnknown_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfNamedUnknown_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfNamedUnknown_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfNamedUnknown_IsAllocated(self)

    def Assign(self, theOther: "Expr_Array1OfNamedUnknown") -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > > &":
        return _Expr.Expr_Array1OfNamedUnknown_Assign(self, theOther)

    def Move(self, theOther: "Expr_Array1OfNamedUnknown") -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > > &":
        return _Expr.Expr_Array1OfNamedUnknown_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< opencascade::handle< Expr_NamedUnknown > > &":
        return _Expr.Expr_Array1OfNamedUnknown_Set(self, *args)

    def First(self) -> "opencascade::handle< Expr_NamedUnknown > const &":
        return _Expr.Expr_Array1OfNamedUnknown_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Expr_NamedUnknown > &":
        return _Expr.Expr_Array1OfNamedUnknown_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Expr_NamedUnknown > const &":
        return _Expr.Expr_Array1OfNamedUnknown_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Expr_NamedUnknown > &":
        return _Expr.Expr_Array1OfNamedUnknown_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_NamedUnknown > const &":
        return _Expr.Expr_Array1OfNamedUnknown_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_NamedUnknown > &":
        return _Expr.Expr_Array1OfNamedUnknown_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Expr_NamedUnknown > &":
        return _Expr.Expr_Array1OfNamedUnknown___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Expr_NamedUnknown > const &") -> "void":
        return _Expr.Expr_Array1OfNamedUnknown_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _Expr.Expr_Array1OfNamedUnknown_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _Expr.delete_Expr_Array1OfNamedUnknown

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register Expr_Array1OfNamedUnknown in _Expr:
_Expr.Expr_Array1OfNamedUnknown_swigregister(Expr_Array1OfNamedUnknown)

class Expr_Array1OfSingleRelation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > >::iterator":
        return _Expr.Expr_Array1OfSingleRelation_begin(self)

    def end(self) -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > >::iterator":
        return _Expr.Expr_Array1OfSingleRelation_end(self)

    def cbegin(self) -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > >::const_iterator":
        return _Expr.Expr_Array1OfSingleRelation_cbegin(self)

    def cend(self) -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > >::const_iterator":
        return _Expr.Expr_Array1OfSingleRelation_cend(self)

    def __init__(self, *args):
        _Expr.Expr_Array1OfSingleRelation_swiginit(self, _Expr.new_Expr_Array1OfSingleRelation(*args))

    def Init(self, theValue: "opencascade::handle< Expr_SingleRelation > const &") -> "void":
        return _Expr.Expr_Array1OfSingleRelation_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfSingleRelation_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfSingleRelation_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfSingleRelation_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfSingleRelation_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Expr.Expr_Array1OfSingleRelation_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfSingleRelation_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _Expr.Expr_Array1OfSingleRelation_IsAllocated(self)

    def Assign(self, theOther: "Expr_Array1OfSingleRelation") -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > > &":
        return _Expr.Expr_Array1OfSingleRelation_Assign(self, theOther)

    def Move(self, theOther: "Expr_Array1OfSingleRelation") -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > > &":
        return _Expr.Expr_Array1OfSingleRelation_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< opencascade::handle< Expr_SingleRelation > > &":
        return _Expr.Expr_Array1OfSingleRelation_Set(self, *args)

    def First(self) -> "opencascade::handle< Expr_SingleRelation > const &":
        return _Expr.Expr_Array1OfSingleRelation_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Expr_SingleRelation > &":
        return _Expr.Expr_Array1OfSingleRelation_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Expr_SingleRelation > const &":
        return _Expr.Expr_Array1OfSingleRelation_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Expr_SingleRelation > &":
        return _Expr.Expr_Array1OfSingleRelation_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_SingleRelation > const &":
        return _Expr.Expr_Array1OfSingleRelation_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_SingleRelation > &":
        return _Expr.Expr_Array1OfSingleRelation_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Expr_SingleRelation > &":
        return _Expr.Expr_Array1OfSingleRelation___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Expr_SingleRelation > const &") -> "void":
        return _Expr.Expr_Array1OfSingleRelation_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _Expr.Expr_Array1OfSingleRelation_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _Expr.delete_Expr_Array1OfSingleRelation

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register Expr_Array1OfSingleRelation in _Expr:
_Expr.Expr_Array1OfSingleRelation_swigregister(Expr_Array1OfSingleRelation)

class Expr_MapOfNamedUnknown(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def cbegin(self) -> "NCollection_IndexedMap< opencascade::handle< Expr_NamedUnknown >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _Expr.Expr_MapOfNamedUnknown_cbegin(self)

    def cend(self) -> "NCollection_IndexedMap< opencascade::handle< Expr_NamedUnknown >,NCollection_DefaultHasher< opencascade::handle< Standard_Transient > > >::const_iterator":
        return _Expr.Expr_MapOfNamedUnknown_cend(self)

    def __init__(self, *args):
        _Expr.Expr_MapOfNamedUnknown_swiginit(self, _Expr.new_Expr_MapOfNamedUnknown(*args))

    def Exchange(self, theOther: "Expr_MapOfNamedUnknown") -> "void":
        return _Expr.Expr_MapOfNamedUnknown_Exchange(self, theOther)

    def Assign(self, theOther: "Expr_MapOfNamedUnknown") -> "NCollection_IndexedMap< opencascade::handle< Expr_NamedUnknown >,TColStd_MapTransientHasher > &":
        return _Expr.Expr_MapOfNamedUnknown_Assign(self, theOther)

    def Set(self, theOther: "Expr_MapOfNamedUnknown") -> "NCollection_IndexedMap< opencascade::handle< Expr_NamedUnknown >,TColStd_MapTransientHasher > &":
        return _Expr.Expr_MapOfNamedUnknown_Set(self, theOther)

    def ReSize(self, theExtent: "Standard_Integer const") -> "void":
        return _Expr.Expr_MapOfNamedUnknown_ReSize(self, theExtent)

    def Add(self, theKey1: "opencascade::handle< Expr_NamedUnknown > const &") -> "Standard_Integer":
        return _Expr.Expr_MapOfNamedUnknown_Add(self, theKey1)

    def Contains(self, theKey1: "opencascade::handle< Expr_NamedUnknown > const &") -> "Standard_Boolean":
        return _Expr.Expr_MapOfNamedUnknown_Contains(self, theKey1)

    def Substitute(self, theIndex: "Standard_Integer const", theKey1: "opencascade::handle< Expr_NamedUnknown > const &") -> "void":
        return _Expr.Expr_MapOfNamedUnknown_Substitute(self, theIndex, theKey1)

    def Swap(self, theIndex1: "Standard_Integer const", theIndex2: "Standard_Integer const") -> "void":
        return _Expr.Expr_MapOfNamedUnknown_Swap(self, theIndex1, theIndex2)

    def RemoveLast(self) -> "void":
        return _Expr.Expr_MapOfNamedUnknown_RemoveLast(self)

    def RemoveFromIndex(self, theIndex: "Standard_Integer const") -> "void":
        return _Expr.Expr_MapOfNamedUnknown_RemoveFromIndex(self, theIndex)

    def RemoveKey(self, theKey1: "opencascade::handle< Expr_NamedUnknown > const &") -> "Standard_Boolean":
        return _Expr.Expr_MapOfNamedUnknown_RemoveKey(self, theKey1)

    def FindKey(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_NamedUnknown > const &":
        return _Expr.Expr_MapOfNamedUnknown_FindKey(self, theIndex)

    def __call__(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_NamedUnknown > const &":
        return _Expr.Expr_MapOfNamedUnknown___call__(self, theIndex)

    def FindIndex(self, theKey1: "opencascade::handle< Expr_NamedUnknown > const &") -> "Standard_Integer":
        return _Expr.Expr_MapOfNamedUnknown_FindIndex(self, theKey1)

    def Clear(self, *args) -> "void":
        return _Expr.Expr_MapOfNamedUnknown_Clear(self, *args)
    __swig_destroy__ = _Expr.delete_Expr_MapOfNamedUnknown

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_MapOfNamedUnknown_Size(self)

# Register Expr_MapOfNamedUnknown in _Expr:
_Expr.Expr_MapOfNamedUnknown_swigregister(Expr_MapOfNamedUnknown)

class Expr_SequenceOfGeneralExpression(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > >::iterator":
        return _Expr.Expr_SequenceOfGeneralExpression_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > >::iterator":
        return _Expr.Expr_SequenceOfGeneralExpression_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > >::const_iterator":
        return _Expr.Expr_SequenceOfGeneralExpression_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > >::const_iterator":
        return _Expr.Expr_SequenceOfGeneralExpression_cend(self)

    def __init__(self, *args):
        _Expr.Expr_SequenceOfGeneralExpression_swiginit(self, _Expr.new_Expr_SequenceOfGeneralExpression(*args))

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralExpression_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralExpression_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralExpression_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralExpression_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Expr.Expr_SequenceOfGeneralExpression_IsEmpty(self)

    def Reverse(self) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Clear(self, theAllocator)

    def Assign(self, theOther: "Expr_SequenceOfGeneralExpression") -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > > &":
        return _Expr.Expr_SequenceOfGeneralExpression_Assign(self, theOther)

    def Set(self, theOther: "Expr_SequenceOfGeneralExpression") -> "NCollection_Sequence< opencascade::handle< Expr_GeneralExpression > > &":
        return _Expr.Expr_SequenceOfGeneralExpression_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "Expr_SequenceOfGeneralExpression") -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_SequenceOfGeneralExpression_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_SequenceOfGeneralExpression_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_SequenceOfGeneralExpression_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_SequenceOfGeneralExpression_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralExpression > const &":
        return _Expr.Expr_SequenceOfGeneralExpression_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_SequenceOfGeneralExpression_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Expr_GeneralExpression > &":
        return _Expr.Expr_SequenceOfGeneralExpression___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Expr_GeneralExpression > const &") -> "void":
        return _Expr.Expr_SequenceOfGeneralExpression_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _Expr.delete_Expr_SequenceOfGeneralExpression

    def __len__(self):
        return self.Size()


# Register Expr_SequenceOfGeneralExpression in _Expr:
_Expr.Expr_SequenceOfGeneralExpression_swigregister(Expr_SequenceOfGeneralExpression)

def Expr_SequenceOfGeneralExpression_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _Expr.Expr_SequenceOfGeneralExpression_delNode(theNode, theAl)

class Expr_SequenceOfGeneralRelation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > >::iterator":
        return _Expr.Expr_SequenceOfGeneralRelation_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > >::iterator":
        return _Expr.Expr_SequenceOfGeneralRelation_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > >::const_iterator":
        return _Expr.Expr_SequenceOfGeneralRelation_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > >::const_iterator":
        return _Expr.Expr_SequenceOfGeneralRelation_cend(self)

    def __init__(self, *args):
        _Expr.Expr_SequenceOfGeneralRelation_swiginit(self, _Expr.new_Expr_SequenceOfGeneralRelation(*args))

    def Size(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralRelation_Size(self)

    def Length(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralRelation_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralRelation_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _Expr.Expr_SequenceOfGeneralRelation_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _Expr.Expr_SequenceOfGeneralRelation_IsEmpty(self)

    def Reverse(self) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Clear(self, theAllocator)

    def Assign(self, theOther: "Expr_SequenceOfGeneralRelation") -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > > &":
        return _Expr.Expr_SequenceOfGeneralRelation_Assign(self, theOther)

    def Set(self, theOther: "Expr_SequenceOfGeneralRelation") -> "NCollection_Sequence< opencascade::handle< Expr_GeneralRelation > > &":
        return _Expr.Expr_SequenceOfGeneralRelation_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "Expr_SequenceOfGeneralRelation") -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< Expr_GeneralRelation > const &":
        return _Expr.Expr_SequenceOfGeneralRelation_First(self)

    def ChangeFirst(self) -> "opencascade::handle< Expr_GeneralRelation > &":
        return _Expr.Expr_SequenceOfGeneralRelation_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< Expr_GeneralRelation > const &":
        return _Expr.Expr_SequenceOfGeneralRelation_Last(self)

    def ChangeLast(self) -> "opencascade::handle< Expr_GeneralRelation > &":
        return _Expr.Expr_SequenceOfGeneralRelation_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralRelation > const &":
        return _Expr.Expr_SequenceOfGeneralRelation_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< Expr_GeneralRelation > &":
        return _Expr.Expr_SequenceOfGeneralRelation_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< Expr_GeneralRelation > &":
        return _Expr.Expr_SequenceOfGeneralRelation___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< Expr_GeneralRelation > const &") -> "void":
        return _Expr.Expr_SequenceOfGeneralRelation_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _Expr.delete_Expr_SequenceOfGeneralRelation

    def __len__(self):
        return self.Size()


# Register Expr_SequenceOfGeneralRelation in _Expr:
_Expr.Expr_SequenceOfGeneralRelation_swigregister(Expr_SequenceOfGeneralRelation)

def Expr_SequenceOfGeneralRelation_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _Expr.Expr_SequenceOfGeneralRelation_delNode(theNode, theAl)

class expr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def CopyShare(*args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        No available documentation.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.expr_CopyShare(*args)

    @staticmethod
    def NbOfFreeVariables(*args) -> "Standard_Integer":
        r"""
        No available documentation.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        int
        No available documentation.

        Parameters
        ----------
        exp: Expr_GeneralRelation

        Returns
        -------
        int

        """
        return _Expr.expr_NbOfFreeVariables(*args)

    @staticmethod
    def Sign(*args) -> "Standard_Real":
        r"""
        No available documentation.

        Parameters
        ----------
        val: float

        Returns
        -------
        float

        """
        return _Expr.expr_Sign(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _Expr.expr_swiginit(self, _Expr.new_expr())
    __swig_destroy__ = _Expr.delete_expr

# Register expr in _Expr:
_Expr.expr_swigregister(expr)

def expr_CopyShare(*args) -> "opencascade::handle< Expr_GeneralExpression >":
    r"""
    No available documentation.

    Parameters
    ----------
    exp: Expr_GeneralExpression

    Returns
    -------
    opencascade::handle<Expr_GeneralExpression>

    """
    return _Expr.expr_CopyShare(*args)

def expr_NbOfFreeVariables(*args) -> "Standard_Integer":
    r"""
    No available documentation.

    Parameters
    ----------
    exp: Expr_GeneralExpression

    Returns
    -------
    int
    No available documentation.

    Parameters
    ----------
    exp: Expr_GeneralRelation

    Returns
    -------
    int

    """
    return _Expr.expr_NbOfFreeVariables(*args)

def expr_Sign(*args) -> "Standard_Real":
    r"""
    No available documentation.

    Parameters
    ----------
    val: float

    Returns
    -------
    float

    """
    return _Expr.expr_Sign(*args)

class Expr_GeneralExpression(OCC.Core.Standard.Standard_Transient):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Contains(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <exp> is contained in <self>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralExpression_Contains(self, *args)

    def ContainsUnknowns(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> contains namedunknowns.

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralExpression_ContainsUnknowns(self, *args)

    def Copy(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns a copy of <self> having the same unknowns and functions.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_Copy(self, *args)

    def Derivative(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns the derivative on <x> unknown of <self>.

        Parameters
        ----------
        X: Expr_NamedUnknown

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_Derivative(self, *args)

    def Evaluate(self, *args) -> "Standard_Real":
        r"""
        Returns the value of <self> (as a real) by replacement of <vars> by <vals>. raises notevaluable if <self> contains namedunknown not in <vars> or numericerror if result cannot be computed.

        Parameters
        ----------
        vars: Expr_Array1OfNamedUnknown
        vals: TColStd_Array1OfReal

        Returns
        -------
        float

        """
        return _Expr.Expr_GeneralExpression_Evaluate(self, *args)

    def EvaluateNumeric(self, *args) -> "Standard_Real":
        r"""
        Returns the value of <self> (as a real) by replacement of <vars> by <vals>. raises notevaluable if <self> contains namedunknown not in <vars> or numericerror if result cannot be computed.

        Returns
        -------
        float

        """
        return _Expr.Expr_GeneralExpression_EvaluateNumeric(self, *args)

    def IsIdentical(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> and <other> define the same expression. warning: this method does not include any simplification before testing. it could also be very slow; to be used carefully.

        Parameters
        ----------
        Other: Expr_GeneralExpression

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralExpression_IsIdentical(self, *args)

    def IsLinear(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> is linear on every namedunknown it contains.

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralExpression_IsLinear(self, *args)

    def IsShareable(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> can be shared by one or more expressions or must be copied. this method returns false as a default value. to be redefined ( especially for namedunknown).

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralExpression_IsShareable(self, *args)

    def NDerivative(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns the <n>-th derivative on <x> unknown of <self>. raise outofrange if n <= 0.

        Parameters
        ----------
        X: Expr_NamedUnknown
        N: int

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_NDerivative(self, *args)

    def NbSubExpressions(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of sub-expressions contained in <self> ( >= 0).

        Returns
        -------
        int

        """
        return _Expr.Expr_GeneralExpression_NbSubExpressions(self, *args)

    def Replace(self, *args) -> "void":
        r"""
        Replaces all occurences of <var> with copies of <with> in <self>. copies of <with> are made with the copy() method. raises invalidoperand if <with> contains <self>.

        Parameters
        ----------
        var: Expr_NamedUnknown
        with: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_GeneralExpression_Replace(self, *args)

    def ShallowSimplified(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns a generalexpression after a simplification of the arguments of <self>.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_ShallowSimplified(self, *args)

    def Simplified(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns a generalexpression after replacement of namedunknowns by an associated expression and after values computation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_Simplified(self, *args)

    def String(self, *args) -> "TCollection_AsciiString":
        r"""
        Returns a string representing <self> in a readable way.

        Returns
        -------
        TCollection_AsciiString

        """
        return _Expr.Expr_GeneralExpression_String(self, *args)

    def SubExpression(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        Returns the <i>-th sub-expression of <self> raises outofrange if <i> > nbsubexpressions(me).

        Parameters
        ----------
        I: int

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_GeneralExpression_SubExpression(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_GeneralExpression_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_GeneralExpression

# Register Expr_GeneralExpression in _Expr:
_Expr.Expr_GeneralExpression_swigregister(Expr_GeneralExpression)

class Expr_GeneralFunction(OCC.Core.Standard.Standard_Transient):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Copy(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns a copy of <self> with the same form.

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_GeneralFunction_Copy(self, *args)

    def Derivative(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns derivative of <self> for variable <var>.

        Parameters
        ----------
        var: Expr_NamedUnknown

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>
        Returns derivative of <self> for variable <var> with degree <deg>.

        Parameters
        ----------
        var: Expr_NamedUnknown
        deg: int

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_GeneralFunction_Derivative(self, *args)

    def Evaluate(self, *args) -> "Standard_Real":
        r"""
        Computes the value of <self> with the given variables. raises notevaluable if <vars> does not match all variables of <self>.

        Parameters
        ----------
        vars: Expr_Array1OfNamedUnknown
        vals: TColStd_Array1OfReal

        Returns
        -------
        float

        """
        return _Expr.Expr_GeneralFunction_Evaluate(self, *args)

    def GetStringName(self, *args) -> "TCollection_AsciiString":
        r"""
        No available documentation.

        Returns
        -------
        TCollection_AsciiString

        """
        return _Expr.Expr_GeneralFunction_GetStringName(self, *args)

    def IsIdentical(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> and <func> are similar functions (same name and same used expression).

        Parameters
        ----------
        func: Expr_GeneralFunction

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralFunction_IsIdentical(self, *args)

    def IsLinearOnVariable(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> is linear on variable on range <index>.

        Parameters
        ----------
        index: int

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralFunction_IsLinearOnVariable(self, *args)

    def NbOfVariables(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of variables of <self>.

        Returns
        -------
        int

        """
        return _Expr.Expr_GeneralFunction_NbOfVariables(self, *args)

    def Variable(self, *args) -> "opencascade::handle< Expr_NamedUnknown >":
        r"""
        Returns the variable denoted by <index> in <self>. raises outofrange if index > nbofvariables.

        Parameters
        ----------
        index: int

        Returns
        -------
        opencascade::handle<Expr_NamedUnknown>

        """
        return _Expr.Expr_GeneralFunction_Variable(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_GeneralFunction_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_GeneralFunction

# Register Expr_GeneralFunction in _Expr:
_Expr.Expr_GeneralFunction_swigregister(Expr_GeneralFunction)

class Expr_GeneralRelation(OCC.Core.Standard.Standard_Transient):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Contains(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <exp> contains <var>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralRelation_Contains(self, *args)

    def Copy(self, *args) -> "opencascade::handle< Expr_GeneralRelation >":
        r"""
        Returns a copy of <self> having the same unknowns and functions.

        Returns
        -------
        opencascade::handle<Expr_GeneralRelation>

        """
        return _Expr.Expr_GeneralRelation_Copy(self, *args)

    def IsLinear(self, *args) -> "Standard_Boolean":
        r"""
        Tests if <self> is linear between its namedunknowns.

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralRelation_IsLinear(self, *args)

    def IsSatisfied(self, *args) -> "Standard_Boolean":
        r"""
        Returns the current status of the relation.

        Returns
        -------
        bool

        """
        return _Expr.Expr_GeneralRelation_IsSatisfied(self, *args)

    def NbOfSingleRelations(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of singlerelations contained in <self>.

        Returns
        -------
        int

        """
        return _Expr.Expr_GeneralRelation_NbOfSingleRelations(self, *args)

    def NbOfSubRelations(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of relations contained in <self>.

        Returns
        -------
        int

        """
        return _Expr.Expr_GeneralRelation_NbOfSubRelations(self, *args)

    def Replace(self, *args) -> "void":
        r"""
        Replaces all occurences of <var> with <with> in <self>.

        Parameters
        ----------
        var: Expr_NamedUnknown
        with: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_GeneralRelation_Replace(self, *args)

    def Simplified(self, *args) -> "opencascade::handle< Expr_GeneralRelation >":
        r"""
        Returns a generalrelation after replacement of namedunknowns by an associated expression, and after values computation.

        Returns
        -------
        opencascade::handle<Expr_GeneralRelation>

        """
        return _Expr.Expr_GeneralRelation_Simplified(self, *args)

    def Simplify(self, *args) -> "void":
        r"""
        Replaces namedunknowns by associated expressions, and computes values in <self>.

        Returns
        -------
        None

        """
        return _Expr.Expr_GeneralRelation_Simplify(self, *args)

    def String(self, *args) -> "TCollection_AsciiString":
        r"""
        Returns a string representing <self> in a readable way.

        Returns
        -------
        TCollection_AsciiString

        """
        return _Expr.Expr_GeneralRelation_String(self, *args)

    def SubRelation(self, *args) -> "opencascade::handle< Expr_GeneralRelation >":
        r"""
        Returns the relation denoted by <index> in <self>. an exception is raised if <index> is out of range.

        Parameters
        ----------
        index: int

        Returns
        -------
        opencascade::handle<Expr_GeneralRelation>

        """
        return _Expr.Expr_GeneralRelation_SubRelation(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_GeneralRelation_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_GeneralRelation

# Register Expr_GeneralRelation in _Expr:
_Expr.Expr_GeneralRelation_swigregister(Expr_GeneralRelation)

class Expr_RUIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates an iterator on every namedunknown contained in <rel>.

        Parameters
        ----------
        rel: Expr_GeneralRelation

        Returns
        -------
        None

        """
        _Expr.Expr_RUIterator_swiginit(self, _Expr.new_Expr_RUIterator(*args))

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns false if on other unknown remains.

        Returns
        -------
        bool

        """
        return _Expr.Expr_RUIterator_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        No available documentation.

        Returns
        -------
        None

        """
        return _Expr.Expr_RUIterator_Next(self, *args)

    def Value(self, *args) -> "opencascade::handle< Expr_NamedUnknown >":
        r"""
        Returns current namedunknown. raises exception if no more unknowns remain.

        Returns
        -------
        opencascade::handle<Expr_NamedUnknown>

        """
        return _Expr.Expr_RUIterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_RUIterator

# Register Expr_RUIterator in _Expr:
_Expr.Expr_RUIterator_swigregister(Expr_RUIterator)

class Expr_RelationIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        rel: Expr_GeneralRelation

        Returns
        -------
        None

        """
        _Expr.Expr_RelationIterator_swiginit(self, _Expr.new_Expr_RelationIterator(*args))

    def More(self, *args) -> "Standard_Boolean":
        r"""
        Returns false if no other relation remains.

        Returns
        -------
        bool

        """
        return _Expr.Expr_RelationIterator_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        No available documentation.

        Returns
        -------
        None

        """
        return _Expr.Expr_RelationIterator_Next(self, *args)

    def Value(self, *args) -> "opencascade::handle< Expr_SingleRelation >":
        r"""
        Returns current basic relation. exception is raised if no more relation remains.

        Returns
        -------
        opencascade::handle<Expr_SingleRelation>

        """
        return _Expr.Expr_RelationIterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_RelationIterator

# Register Expr_RelationIterator in _Expr:
_Expr.Expr_RelationIterator_swigregister(Expr_RelationIterator)

class Expr_UnknownIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_UnknownIterator_swiginit(self, _Expr.new_Expr_UnknownIterator(*args))

    def More(self, *args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Returns
        -------
        bool

        """
        return _Expr.Expr_UnknownIterator_More(self, *args)

    def Next(self, *args) -> "void":
        r"""
        No available documentation.

        Returns
        -------
        None

        """
        return _Expr.Expr_UnknownIterator_Next(self, *args)

    def Value(self, *args) -> "opencascade::handle< Expr_NamedUnknown >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Expr_NamedUnknown>

        """
        return _Expr.Expr_UnknownIterator_Value(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_UnknownIterator

# Register Expr_UnknownIterator in _Expr:
_Expr.Expr_UnknownIterator_swigregister(Expr_UnknownIterator)

class Expr_BinaryExpression(Expr_GeneralExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def FirstOperand(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_BinaryExpression_FirstOperand(self, *args)

    def SecondOperand(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_BinaryExpression_SecondOperand(self, *args)

    def SetFirstOperand(self, *args) -> "void":
        r"""
        Sets first operand of <self> raises invalidoperand if exp = me.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_BinaryExpression_SetFirstOperand(self, *args)

    def SetSecondOperand(self, *args) -> "void":
        r"""
        Sets second operand of <self> raises invalidoperand if <exp> contains <self>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_BinaryExpression_SetSecondOperand(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_BinaryExpression_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_BinaryExpression

# Register Expr_BinaryExpression in _Expr:
_Expr.Expr_BinaryExpression_swigregister(Expr_BinaryExpression)

class Expr_FunctionDerivative(Expr_GeneralFunction):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a functionderivative of degree <deg> relative to the <withx> variable. raises outofrange if <deg> lower or equal to zero.

        Parameters
        ----------
        func: Expr_GeneralFunction
        withX: Expr_NamedUnknown
        deg: int

        Returns
        -------
        None

        """
        _Expr.Expr_FunctionDerivative_swiginit(self, _Expr.new_Expr_FunctionDerivative(*args))

    def Degree(self, *args) -> "Standard_Integer":
        r"""
        Returns the degree of derivation of <self>.

        Returns
        -------
        int

        """
        return _Expr.Expr_FunctionDerivative_Degree(self, *args)

    def DerivVariable(self, *args) -> "opencascade::handle< Expr_NamedUnknown >":
        r"""
        Returns the derivation variable of <self>.

        Returns
        -------
        opencascade::handle<Expr_NamedUnknown>

        """
        return _Expr.Expr_FunctionDerivative_DerivVariable(self, *args)

    def Derivative(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns derivative of <self> for variable <var>.

        Parameters
        ----------
        var: Expr_NamedUnknown

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>
        Returns derivative of <self> for variable <var> with degree <deg>.

        Parameters
        ----------
        var: Expr_NamedUnknown
        deg: int

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_FunctionDerivative_Derivative(self, *args)

    def Expression(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_FunctionDerivative_Expression(self, *args)

    def Function(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns the function of which <self> is the derivative.

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_FunctionDerivative_Function(self, *args)

    def UpdateExpression(self, *args) -> "void":
        r"""
        No available documentation.

        Returns
        -------
        None

        """
        return _Expr.Expr_FunctionDerivative_UpdateExpression(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_FunctionDerivative_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_FunctionDerivative

# Register Expr_FunctionDerivative in _Expr:
_Expr.Expr_FunctionDerivative_swigregister(Expr_FunctionDerivative)

class Expr_NamedExpression(Expr_GeneralExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def GetName(self, *args) -> "TCollection_AsciiString const &":
        r"""
        No available documentation.

        Returns
        -------
        TCollection_AsciiString

        """
        return _Expr.Expr_NamedExpression_GetName(self, *args)

    def SetName(self, *args) -> "void":
        r"""
        No available documentation.

        Parameters
        ----------
        name: TCollection_AsciiString

        Returns
        -------
        None

        """
        return _Expr.Expr_NamedExpression_SetName(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_NamedExpression_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_NamedExpression

# Register Expr_NamedExpression in _Expr:
_Expr.Expr_NamedExpression_swigregister(Expr_NamedExpression)

class Expr_NamedFunction(Expr_GeneralFunction):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a function of given variables <vars> with name <name> defined by the expression <exp>.

        Parameters
        ----------
        name: TCollection_AsciiString
        exp: Expr_GeneralExpression
        vars: Expr_Array1OfNamedUnknown

        Returns
        -------
        None

        """
        _Expr.Expr_NamedFunction_swiginit(self, _Expr.new_Expr_NamedFunction(*args))

    def Derivative(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns derivative of <self> for variable <var>.

        Parameters
        ----------
        var: Expr_NamedUnknown

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>
        Returns derivative of <self> for variable <var> with degree <deg>.

        Parameters
        ----------
        var: Expr_NamedUnknown
        deg: int

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_NamedFunction_Derivative(self, *args)

    def Expression(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns equivalent expression of <self>.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_NamedFunction_Expression(self, *args)

    def GetName(self, *args) -> "TCollection_AsciiString":
        r"""
        Returns the name assigned to <self>.

        Returns
        -------
        TCollection_AsciiString

        """
        return _Expr.Expr_NamedFunction_GetName(self, *args)

    def SetExpression(self, *args) -> "void":
        r"""
        Modifies expression of <self>. warning: beware of derivatives. see functionderivative.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_NamedFunction_SetExpression(self, *args)

    def SetName(self, *args) -> "void":
        r"""
        Sets the name <newname> to <self>.

        Parameters
        ----------
        newname: TCollection_AsciiString

        Returns
        -------
        None

        """
        return _Expr.Expr_NamedFunction_SetName(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_NamedFunction_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_NamedFunction

# Register Expr_NamedFunction in _Expr:
_Expr.Expr_NamedFunction_swigregister(Expr_NamedFunction)

class Expr_NumericValue(Expr_GeneralExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        val: float

        Returns
        -------
        None

        """
        _Expr.Expr_NumericValue_swiginit(self, _Expr.new_Expr_NumericValue(*args))

    def GetValue(self, *args) -> "Standard_Real":
        r"""
        No available documentation.

        Returns
        -------
        float

        """
        return _Expr.Expr_NumericValue_GetValue(self, *args)

    def SetValue(self, *args) -> "void":
        r"""
        No available documentation.

        Parameters
        ----------
        val: float

        Returns
        -------
        None

        """
        return _Expr.Expr_NumericValue_SetValue(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_NumericValue_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_NumericValue

# Register Expr_NumericValue in _Expr:
_Expr.Expr_NumericValue_swigregister(Expr_NumericValue)

class Expr_PolyExpression(Expr_GeneralExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def NbOperands(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of operands contained in <self>.

        Returns
        -------
        int

        """
        return _Expr.Expr_PolyExpression_NbOperands(self, *args)

    def Operand(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        Returns the <index>-th operand used in <self>. an exception is raised if index is out of range.

        Parameters
        ----------
        index: int

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_PolyExpression_Operand(self, *args)

    def SetOperand(self, *args) -> "void":
        r"""
        Sets the <index>-th operand used in <self>. an exception is raised if <index> is out of range raises invalidoperand if <exp> contains <self>.

        Parameters
        ----------
        exp: Expr_GeneralExpression
        index: int

        Returns
        -------
        None

        """
        return _Expr.Expr_PolyExpression_SetOperand(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_PolyExpression_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_PolyExpression

# Register Expr_PolyExpression in _Expr:
_Expr.Expr_PolyExpression_swigregister(Expr_PolyExpression)

class Expr_SingleRelation(Expr_GeneralRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def FirstMember(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns the first member of the relation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_SingleRelation_FirstMember(self, *args)

    def SecondMember(self, *args) -> "opencascade::handle< Expr_GeneralExpression >":
        r"""
        Returns the second member of the relation.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_SingleRelation_SecondMember(self, *args)

    def SetFirstMember(self, *args) -> "void":
        r"""
        Defines the first member of the relation.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_SingleRelation_SetFirstMember(self, *args)

    def SetSecondMember(self, *args) -> "void":
        r"""
        Defines the second member of the relation.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_SingleRelation_SetSecondMember(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_SingleRelation_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_SingleRelation

# Register Expr_SingleRelation in _Expr:
_Expr.Expr_SingleRelation_swigregister(Expr_SingleRelation)

class Expr_SystemRelation(Expr_GeneralRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a system with one relation.

        Parameters
        ----------
        relation: Expr_GeneralRelation

        Returns
        -------
        None

        """
        _Expr.Expr_SystemRelation_swiginit(self, _Expr.new_Expr_SystemRelation(*args))

    def Add(self, *args) -> "void":
        r"""
        Appends <relation> in the list of components of <self>.

        Parameters
        ----------
        relation: Expr_GeneralRelation

        Returns
        -------
        None

        """
        return _Expr.Expr_SystemRelation_Add(self, *args)

    def Remove(self, *args) -> "void":
        r"""
        No available documentation.

        Parameters
        ----------
        relation: Expr_GeneralRelation

        Returns
        -------
        None

        """
        return _Expr.Expr_SystemRelation_Remove(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_SystemRelation_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_SystemRelation

# Register Expr_SystemRelation in _Expr:
_Expr.Expr_SystemRelation_swigregister(Expr_SystemRelation)

class Expr_UnaryExpression(Expr_GeneralExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def Operand(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        Returns the operand used.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_UnaryExpression_Operand(self, *args)

    def SetOperand(self, *args) -> "void":
        r"""
        Sets the operand used raises invalidoperand if <exp> contains <self>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_UnaryExpression_SetOperand(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_UnaryExpression_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_UnaryExpression

# Register Expr_UnaryExpression in _Expr:
_Expr.Expr_UnaryExpression_swigregister(Expr_UnaryExpression)

class Expr_Absolute(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the abs of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Absolute_swiginit(self, _Expr.new_Expr_Absolute(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Absolute_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Absolute

# Register Expr_Absolute in _Expr:
_Expr.Expr_Absolute_swigregister(Expr_Absolute)

class Expr_ArcCosine(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the arccos of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArcCosine_swiginit(self, _Expr.new_Expr_ArcCosine(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArcCosine_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArcCosine

# Register Expr_ArcCosine in _Expr:
_Expr.Expr_ArcCosine_swigregister(Expr_ArcCosine)

class Expr_ArcSine(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the arcsin of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArcSine_swiginit(self, _Expr.new_Expr_ArcSine(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArcSine_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArcSine

# Register Expr_ArcSine in _Expr:
_Expr.Expr_ArcSine_swigregister(Expr_ArcSine)

class Expr_ArcTangent(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the arctan of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArcTangent_swiginit(self, _Expr.new_Expr_ArcTangent(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArcTangent_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArcTangent

# Register Expr_ArcTangent in _Expr:
_Expr.Expr_ArcTangent_swigregister(Expr_ArcTangent)

class Expr_ArgCosh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the argcosh of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArgCosh_swiginit(self, _Expr.new_Expr_ArgCosh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArgCosh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArgCosh

# Register Expr_ArgCosh in _Expr:
_Expr.Expr_ArgCosh_swigregister(Expr_ArgCosh)

class Expr_ArgSinh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the argsinh of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArgSinh_swiginit(self, _Expr.new_Expr_ArgSinh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArgSinh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArgSinh

# Register Expr_ArgSinh in _Expr:
_Expr.Expr_ArgSinh_swigregister(Expr_ArgSinh)

class Expr_ArgTanh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the argtanh of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_ArgTanh_swiginit(self, _Expr.new_Expr_ArgTanh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_ArgTanh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_ArgTanh

# Register Expr_ArgTanh in _Expr:
_Expr.Expr_ArgTanh_swigregister(Expr_ArgTanh)

class Expr_BinaryFunction(Expr_BinaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates <self> as <func> (<exp1>,<exp2>). raises exception if <func> is not binary.

        Parameters
        ----------
        func: Expr_GeneralFunction
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_BinaryFunction_swiginit(self, _Expr.new_Expr_BinaryFunction(*args))

    def Function(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns the function defining <self>.

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_BinaryFunction_Function(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_BinaryFunction_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_BinaryFunction

# Register Expr_BinaryFunction in _Expr:
_Expr.Expr_BinaryFunction_swigregister(Expr_BinaryFunction)

class Expr_Cosh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the cosh of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Cosh_swiginit(self, _Expr.new_Expr_Cosh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Cosh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Cosh

# Register Expr_Cosh in _Expr:
_Expr.Expr_Cosh_swigregister(Expr_Cosh)

class Expr_Cosine(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the cosine of exp.

        Parameters
        ----------
        Exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Cosine_swiginit(self, _Expr.new_Expr_Cosine(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Cosine_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Cosine

# Register Expr_Cosine in _Expr:
_Expr.Expr_Cosine_swigregister(Expr_Cosine)

class Expr_Difference(Expr_BinaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the difference <exp1> - <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Difference_swiginit(self, _Expr.new_Expr_Difference(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Difference_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Difference

# Register Expr_Difference in _Expr:
_Expr.Expr_Difference_swigregister(Expr_Difference)

class Expr_Different(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> # <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Different_swiginit(self, _Expr.new_Expr_Different(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Different_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Different

# Register Expr_Different in _Expr:
_Expr.Expr_Different_swigregister(Expr_Different)

class Expr_Division(Expr_BinaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the division <exp1>/<exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Division_swiginit(self, _Expr.new_Expr_Division(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Division_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Division

# Register Expr_Division in _Expr:
_Expr.Expr_Division_swigregister(Expr_Division)

class Expr_Equal(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> = <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Equal_swiginit(self, _Expr.new_Expr_Equal(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Equal_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Equal

# Register Expr_Equal in _Expr:
_Expr.Expr_Equal_swigregister(Expr_Equal)

class Expr_Exponential(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the exponential of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Exponential_swiginit(self, _Expr.new_Expr_Exponential(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Exponential_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Exponential

# Register Expr_Exponential in _Expr:
_Expr.Expr_Exponential_swigregister(Expr_Exponential)

class Expr_Exponentiate(Expr_BinaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the exponential <exp1> ^ <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Exponentiate_swiginit(self, _Expr.new_Expr_Exponentiate(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Exponentiate_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Exponentiate

# Register Expr_Exponentiate in _Expr:
_Expr.Expr_Exponentiate_swigregister(Expr_Exponentiate)

class Expr_GreaterThan(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> > <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_GreaterThan_swiginit(self, _Expr.new_Expr_GreaterThan(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_GreaterThan_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_GreaterThan

# Register Expr_GreaterThan in _Expr:
_Expr.Expr_GreaterThan_swigregister(Expr_GreaterThan)

class Expr_GreaterThanOrEqual(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> >= <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_GreaterThanOrEqual_swiginit(self, _Expr.new_Expr_GreaterThanOrEqual(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_GreaterThanOrEqual_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_GreaterThanOrEqual

# Register Expr_GreaterThanOrEqual in _Expr:
_Expr.Expr_GreaterThanOrEqual_swigregister(Expr_GreaterThanOrEqual)

class Expr_LessThan(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> < <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_LessThan_swiginit(self, _Expr.new_Expr_LessThan(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_LessThan_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_LessThan

# Register Expr_LessThan in _Expr:
_Expr.Expr_LessThan_swigregister(Expr_LessThan)

class Expr_LessThanOrEqual(Expr_SingleRelation):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the relation <exp1> <= <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_LessThanOrEqual_swiginit(self, _Expr.new_Expr_LessThanOrEqual(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_LessThanOrEqual_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_LessThanOrEqual

# Register Expr_LessThanOrEqual in _Expr:
_Expr.Expr_LessThanOrEqual_swigregister(Expr_LessThanOrEqual)

class Expr_LogOf10(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the base 10 logarithm of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_LogOf10_swiginit(self, _Expr.new_Expr_LogOf10(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_LogOf10_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_LogOf10

# Register Expr_LogOf10 in _Expr:
_Expr.Expr_LogOf10_swigregister(Expr_LogOf10)

class Expr_LogOfe(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the natural logarithm of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_LogOfe_swiginit(self, _Expr.new_Expr_LogOfe(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_LogOfe_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_LogOfe

# Register Expr_LogOfe in _Expr:
_Expr.Expr_LogOfe_swigregister(Expr_LogOfe)

class Expr_NamedConstant(Expr_NamedExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates a constant value of name <name> and value <value>.

        Parameters
        ----------
        name: TCollection_AsciiString
        value: float

        Returns
        -------
        None

        """
        _Expr.Expr_NamedConstant_swiginit(self, _Expr.new_Expr_NamedConstant(*args))

    def GetValue(self, *args) -> "Standard_Real":
        r"""
        No available documentation.

        Returns
        -------
        float

        """
        return _Expr.Expr_NamedConstant_GetValue(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_NamedConstant_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_NamedConstant

# Register Expr_NamedConstant in _Expr:
_Expr.Expr_NamedConstant_swigregister(Expr_NamedConstant)

class Expr_NamedUnknown(Expr_NamedExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        name: TCollection_AsciiString

        Returns
        -------
        None

        """
        _Expr.Expr_NamedUnknown_swiginit(self, _Expr.new_Expr_NamedUnknown(*args))

    def Assign(self, *args) -> "void":
        r"""
        Assigns <self> to <exp> expression. raises exception if <exp> refers to <self>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        return _Expr.Expr_NamedUnknown_Assign(self, *args)

    def AssignedExpression(self, *args) -> "opencascade::handle< Expr_GeneralExpression > const &":
        r"""
        If exists, returns the assigned expression. an exception is raised if the expression does not exist.

        Returns
        -------
        opencascade::handle<Expr_GeneralExpression>

        """
        return _Expr.Expr_NamedUnknown_AssignedExpression(self, *args)

    def Deassign(self, *args) -> "void":
        r"""
        Supresses the assigned expression.

        Returns
        -------
        None

        """
        return _Expr.Expr_NamedUnknown_Deassign(self, *args)

    def IsAssigned(self, *args) -> "Standard_Boolean":
        r"""
        Tests if an expression is assigned to <self>.

        Returns
        -------
        bool

        """
        return _Expr.Expr_NamedUnknown_IsAssigned(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_NamedUnknown_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_NamedUnknown

# Register Expr_NamedUnknown in _Expr:
_Expr.Expr_NamedUnknown_swigregister(Expr_NamedUnknown)

class Expr_PolyFunction(Expr_PolyExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates <self> as <func>(<exps_1>,<exps_2>,...,<exps_n>).

        Parameters
        ----------
        func: Expr_GeneralFunction
        exps: Expr_Array1OfGeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_PolyFunction_swiginit(self, _Expr.new_Expr_PolyFunction(*args))

    def Function(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns the function defining <self>.

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_PolyFunction_Function(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_PolyFunction_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_PolyFunction

# Register Expr_PolyFunction in _Expr:
_Expr.Expr_PolyFunction_swigregister(Expr_PolyFunction)

class Expr_Product(Expr_PolyExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the product of all members of sequence <exps>.

        Parameters
        ----------
        exps: Expr_SequenceOfGeneralExpression

        Returns
        -------
        None
        Creates the product of <exp1> and <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Product_swiginit(self, _Expr.new_Expr_Product(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Product_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Product

# Register Expr_Product in _Expr:
_Expr.Expr_Product_swigregister(Expr_Product)

class Expr_Sine(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the sine of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Sine_swiginit(self, _Expr.new_Expr_Sine(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Sine_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Sine

# Register Expr_Sine in _Expr:
_Expr.Expr_Sine_swigregister(Expr_Sine)

class Expr_Sinh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the sinh of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Sinh_swiginit(self, _Expr.new_Expr_Sinh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Sinh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Sinh

# Register Expr_Sinh in _Expr:
_Expr.Expr_Sinh_swigregister(Expr_Sinh)

class Expr_Square(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the square of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Square_swiginit(self, _Expr.new_Expr_Square(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Square_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Square

# Register Expr_Square in _Expr:
_Expr.Expr_Square_swigregister(Expr_Square)

class Expr_SquareRoot(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the square root of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_SquareRoot_swiginit(self, _Expr.new_Expr_SquareRoot(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_SquareRoot_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_SquareRoot

# Register Expr_SquareRoot in _Expr:
_Expr.Expr_SquareRoot_swigregister(Expr_SquareRoot)

class Expr_Sum(Expr_PolyExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the sum of all the members of sequence <exps>.

        Parameters
        ----------
        exps: Expr_SequenceOfGeneralExpression

        Returns
        -------
        None
        Creates the sum of <exp1> and <exp2>.

        Parameters
        ----------
        exp1: Expr_GeneralExpression
        exp2: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Sum_swiginit(self, _Expr.new_Expr_Sum(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Sum_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Sum

# Register Expr_Sum in _Expr:
_Expr.Expr_Sum_swigregister(Expr_Sum)

class Expr_Tangent(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the tangent of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Tangent_swiginit(self, _Expr.new_Expr_Tangent(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Tangent_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Tangent

# Register Expr_Tangent in _Expr:
_Expr.Expr_Tangent_swigregister(Expr_Tangent)

class Expr_Tanh(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates the hyperbolic tangent of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_Tanh_swiginit(self, _Expr.new_Expr_Tanh(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_Tanh_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_Tanh

# Register Expr_Tanh in _Expr:
_Expr.Expr_Tanh_swigregister(Expr_Tanh)

class Expr_UnaryFunction(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Creates me as <func>(<exp>). raises exception if <func> is not unary.

        Parameters
        ----------
        func: Expr_GeneralFunction
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_UnaryFunction_swiginit(self, _Expr.new_Expr_UnaryFunction(*args))

    def Function(self, *args) -> "opencascade::handle< Expr_GeneralFunction >":
        r"""
        Returns the function defining <self>.

        Returns
        -------
        opencascade::handle<Expr_GeneralFunction>

        """
        return _Expr.Expr_UnaryFunction_Function(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_Expr_UnaryFunction_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_UnaryFunction

# Register Expr_UnaryFunction in _Expr:
_Expr.Expr_UnaryFunction_swigregister(Expr_UnaryFunction)

class Expr_UnaryMinus(Expr_UnaryExpression):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Create the unary minus of <exp>.

        Parameters
        ----------
        exp: Expr_GeneralExpression

        Returns
        -------
        None

        """
        _Expr.Expr_UnaryMinus_swiginit(self, _Expr.new_Expr_UnaryMinus(*args))


    @staticmethod
    def DownCast(t):
      return Handle_Expr_UnaryMinus_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _Expr.delete_Expr_UnaryMinus

# Register Expr_UnaryMinus in _Expr:
_Expr.Expr_UnaryMinus_swigregister(Expr_UnaryMinus)


@classnotwrapped
class Expr_Sign:
	pass






