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

"""
Extrema module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_extrema.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 _Extrema
else:
    import _Extrema

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _Extrema.SWIG_PyInstanceMethod_New
_swig_new_static_method = _Extrema.SWIG_PyStaticMethod_New

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__ = _Extrema.delete_SwigPyIterator
    value = _swig_new_instance_method(_Extrema.SwigPyIterator_value)
    incr = _swig_new_instance_method(_Extrema.SwigPyIterator_incr)
    decr = _swig_new_instance_method(_Extrema.SwigPyIterator_decr)
    distance = _swig_new_instance_method(_Extrema.SwigPyIterator_distance)
    equal = _swig_new_instance_method(_Extrema.SwigPyIterator_equal)
    copy = _swig_new_instance_method(_Extrema.SwigPyIterator_copy)
    next = _swig_new_instance_method(_Extrema.SwigPyIterator_next)
    __next__ = _swig_new_instance_method(_Extrema.SwigPyIterator___next__)
    previous = _swig_new_instance_method(_Extrema.SwigPyIterator_previous)
    advance = _swig_new_instance_method(_Extrema.SwigPyIterator_advance)
    __eq__ = _swig_new_instance_method(_Extrema.SwigPyIterator___eq__)
    __ne__ = _swig_new_instance_method(_Extrema.SwigPyIterator___ne__)
    __iadd__ = _swig_new_instance_method(_Extrema.SwigPyIterator___iadd__)
    __isub__ = _swig_new_instance_method(_Extrema.SwigPyIterator___isub__)
    __add__ = _swig_new_instance_method(_Extrema.SwigPyIterator___add__)
    __sub__ = _swig_new_instance_method(_Extrema.SwigPyIterator___sub__)
    def __iter__(self):
        return self

# Register SwigPyIterator in _Extrema:
_Extrema.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


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.math
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.Message
import OCC.Core.gp
import OCC.Core.Adaptor3d
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.TopAbs
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.GeomAdaptor
Extrema_ExtAlgo_Grad = _Extrema.Extrema_ExtAlgo_Grad
Extrema_ExtAlgo_Tree = _Extrema.Extrema_ExtAlgo_Tree
Extrema_ExtFlag_MIN = _Extrema.Extrema_ExtFlag_MIN
Extrema_ExtFlag_MAX = _Extrema.Extrema_ExtFlag_MAX
Extrema_ExtFlag_MINMAX = _Extrema.Extrema_ExtFlag_MINMAX
Extrema_Node = _Extrema.Extrema_Node
Extrema_UIsoEdge = _Extrema.Extrema_UIsoEdge
Extrema_VIsoEdge = _Extrema.Extrema_VIsoEdge
Extrema_Face = _Extrema.Extrema_Face
Handle_Extrema_ExtPExtS_Create = _Extrema.Handle_Extrema_ExtPExtS_Create
Handle_Extrema_ExtPExtS_DownCast = _Extrema.Handle_Extrema_ExtPExtS_DownCast
Handle_Extrema_ExtPExtS_IsNull = _Extrema.Handle_Extrema_ExtPExtS_IsNull
Handle_Extrema_ExtPRevS_Create = _Extrema.Handle_Extrema_ExtPRevS_Create
Handle_Extrema_ExtPRevS_DownCast = _Extrema.Handle_Extrema_ExtPRevS_DownCast
Handle_Extrema_ExtPRevS_IsNull = _Extrema.Handle_Extrema_ExtPRevS_IsNull
Handle_Extrema_HArray1OfPOnSurf_Create = _Extrema.Handle_Extrema_HArray1OfPOnSurf_Create
Handle_Extrema_HArray1OfPOnSurf_DownCast = _Extrema.Handle_Extrema_HArray1OfPOnSurf_DownCast
Handle_Extrema_HArray1OfPOnSurf_IsNull = _Extrema.Handle_Extrema_HArray1OfPOnSurf_IsNull
Handle_Extrema_HArray1OfPOnCurv_Create = _Extrema.Handle_Extrema_HArray1OfPOnCurv_Create
Handle_Extrema_HArray1OfPOnCurv_DownCast = _Extrema.Handle_Extrema_HArray1OfPOnCurv_DownCast
Handle_Extrema_HArray1OfPOnCurv_IsNull = _Extrema.Handle_Extrema_HArray1OfPOnCurv_IsNull
Handle_Extrema_HArray1OfPOnCurv2d_Create = _Extrema.Handle_Extrema_HArray1OfPOnCurv2d_Create
Handle_Extrema_HArray1OfPOnCurv2d_DownCast = _Extrema.Handle_Extrema_HArray1OfPOnCurv2d_DownCast
Handle_Extrema_HArray1OfPOnCurv2d_IsNull = _Extrema.Handle_Extrema_HArray1OfPOnCurv2d_IsNull
Handle_Extrema_HArray2OfPOnCurv2d_Create = _Extrema.Handle_Extrema_HArray2OfPOnCurv2d_Create
Handle_Extrema_HArray2OfPOnCurv2d_DownCast = _Extrema.Handle_Extrema_HArray2OfPOnCurv2d_DownCast
Handle_Extrema_HArray2OfPOnCurv2d_IsNull = _Extrema.Handle_Extrema_HArray2OfPOnCurv2d_IsNull
Handle_Extrema_HArray2OfPOnCurv_Create = _Extrema.Handle_Extrema_HArray2OfPOnCurv_Create
Handle_Extrema_HArray2OfPOnCurv_DownCast = _Extrema.Handle_Extrema_HArray2OfPOnCurv_DownCast
Handle_Extrema_HArray2OfPOnCurv_IsNull = _Extrema.Handle_Extrema_HArray2OfPOnCurv_IsNull
Handle_Extrema_HArray2OfPOnSurf_Create = _Extrema.Handle_Extrema_HArray2OfPOnSurf_Create
Handle_Extrema_HArray2OfPOnSurf_DownCast = _Extrema.Handle_Extrema_HArray2OfPOnSurf_DownCast
Handle_Extrema_HArray2OfPOnSurf_IsNull = _Extrema.Handle_Extrema_HArray2OfPOnSurf_IsNull
Handle_Extrema_HArray2OfPOnSurfParams_Create = _Extrema.Handle_Extrema_HArray2OfPOnSurfParams_Create
Handle_Extrema_HArray2OfPOnSurfParams_DownCast = _Extrema.Handle_Extrema_HArray2OfPOnSurfParams_DownCast
Handle_Extrema_HArray2OfPOnSurfParams_IsNull = _Extrema.Handle_Extrema_HArray2OfPOnSurfParams_IsNull
class Extrema_SequenceOfPOnSurf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_cend)

    def __init__(self, *args):
        _Extrema.Extrema_SequenceOfPOnSurf_swiginit(self, _Extrema.new_Extrema_SequenceOfPOnSurf(*args))
    Size = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Length)
    Lower = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Upper)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_IsEmpty)
    Reverse = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Reverse)
    Exchange = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Exchange)
    delNode = _swig_new_static_method(_Extrema.Extrema_SequenceOfPOnSurf_delNode)
    Clear = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Clear)
    Assign = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Assign)
    Set = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Set)
    Remove = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Remove)
    Append = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Append)
    Prepend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Prepend)
    InsertBefore = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_InsertBefore)
    InsertAfter = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_InsertAfter)
    Split = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Split)
    First = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnSurf_SetValue)
    __swig_destroy__ = _Extrema.delete_Extrema_SequenceOfPOnSurf

# Register Extrema_SequenceOfPOnSurf in _Extrema:
_Extrema.Extrema_SequenceOfPOnSurf_swigregister(Extrema_SequenceOfPOnSurf)
Extrema_SequenceOfPOnSurf_delNode = _Extrema.Extrema_SequenceOfPOnSurf_delNode

class Extrema_Array2OfPOnSurfParams(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):
        _Extrema.Extrema_Array2OfPOnSurfParams_swiginit(self, _Extrema.new_Extrema_Array2OfPOnSurfParams(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Length)
    NbRows = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_NbRows)
    NbColumns = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_NbColumns)
    RowLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_RowLength)
    ColLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_ColLength)
    LowerRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_LowerRow)
    UpperRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_UpperRow)
    LowerCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_LowerCol)
    UpperCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_UpperCol)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_IsDeletable)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Set)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurfParams_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array2OfPOnSurfParams

# Register Extrema_Array2OfPOnSurfParams in _Extrema:
_Extrema.Extrema_Array2OfPOnSurfParams_swigregister(Extrema_Array2OfPOnSurfParams)

class Extrema_Array1OfPOnCurv(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_cend)

    def __init__(self, *args):
        _Extrema.Extrema_Array1OfPOnCurv_swiginit(self, _Extrema.new_Extrema_Array1OfPOnCurv(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Length)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_IsEmpty)
    Lower = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Upper)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_IsDeletable)
    IsAllocated = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_IsAllocated)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Set)
    First = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array1OfPOnCurv

    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 Extrema_Array1OfPOnCurv in _Extrema:
_Extrema.Extrema_Array1OfPOnCurv_swigregister(Extrema_Array1OfPOnCurv)

class Extrema_Array2OfPOnSurf(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):
        _Extrema.Extrema_Array2OfPOnSurf_swiginit(self, _Extrema.new_Extrema_Array2OfPOnSurf(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Length)
    NbRows = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_NbRows)
    NbColumns = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_NbColumns)
    RowLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_RowLength)
    ColLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_ColLength)
    LowerRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_LowerRow)
    UpperRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_UpperRow)
    LowerCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_LowerCol)
    UpperCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_UpperCol)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_IsDeletable)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Set)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnSurf_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array2OfPOnSurf

# Register Extrema_Array2OfPOnSurf in _Extrema:
_Extrema.Extrema_Array2OfPOnSurf_swigregister(Extrema_Array2OfPOnSurf)

class Extrema_Array2OfPOnCurv2d(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):
        _Extrema.Extrema_Array2OfPOnCurv2d_swiginit(self, _Extrema.new_Extrema_Array2OfPOnCurv2d(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Length)
    NbRows = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_NbRows)
    NbColumns = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_NbColumns)
    RowLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_RowLength)
    ColLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_ColLength)
    LowerRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_LowerRow)
    UpperRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_UpperRow)
    LowerCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_LowerCol)
    UpperCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_UpperCol)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_IsDeletable)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Set)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv2d_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array2OfPOnCurv2d

# Register Extrema_Array2OfPOnCurv2d in _Extrema:
_Extrema.Extrema_Array2OfPOnCurv2d_swigregister(Extrema_Array2OfPOnCurv2d)

class Extrema_Array1OfPOnCurv2d(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_cend)

    def __init__(self, *args):
        _Extrema.Extrema_Array1OfPOnCurv2d_swiginit(self, _Extrema.new_Extrema_Array1OfPOnCurv2d(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Length)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_IsEmpty)
    Lower = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Upper)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_IsDeletable)
    IsAllocated = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_IsAllocated)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Set)
    First = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnCurv2d_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array1OfPOnCurv2d

    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 Extrema_Array1OfPOnCurv2d in _Extrema:
_Extrema.Extrema_Array1OfPOnCurv2d_swigregister(Extrema_Array1OfPOnCurv2d)

class Extrema_SequenceOfPOnCurv(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_cend)

    def __init__(self, *args):
        _Extrema.Extrema_SequenceOfPOnCurv_swiginit(self, _Extrema.new_Extrema_SequenceOfPOnCurv(*args))
    Size = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Length)
    Lower = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Upper)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_IsEmpty)
    Reverse = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Reverse)
    Exchange = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Exchange)
    delNode = _swig_new_static_method(_Extrema.Extrema_SequenceOfPOnCurv_delNode)
    Clear = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Clear)
    Assign = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Assign)
    Set = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Set)
    Remove = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Remove)
    Append = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Append)
    Prepend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Prepend)
    InsertBefore = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_InsertBefore)
    InsertAfter = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_InsertAfter)
    Split = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Split)
    First = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv_SetValue)
    __swig_destroy__ = _Extrema.delete_Extrema_SequenceOfPOnCurv

# Register Extrema_SequenceOfPOnCurv in _Extrema:
_Extrema.Extrema_SequenceOfPOnCurv_swigregister(Extrema_SequenceOfPOnCurv)
Extrema_SequenceOfPOnCurv_delNode = _Extrema.Extrema_SequenceOfPOnCurv_delNode

class Extrema_SequenceOfPOnCurv2d(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_cend)

    def __init__(self, *args):
        _Extrema.Extrema_SequenceOfPOnCurv2d_swiginit(self, _Extrema.new_Extrema_SequenceOfPOnCurv2d(*args))
    Size = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Length)
    Lower = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Upper)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_IsEmpty)
    Reverse = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Reverse)
    Exchange = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Exchange)
    delNode = _swig_new_static_method(_Extrema.Extrema_SequenceOfPOnCurv2d_delNode)
    Clear = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Clear)
    Assign = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Assign)
    Set = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Set)
    Remove = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Remove)
    Append = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Append)
    Prepend = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Prepend)
    InsertBefore = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_InsertBefore)
    InsertAfter = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_InsertAfter)
    Split = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Split)
    First = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_SequenceOfPOnCurv2d_SetValue)
    __swig_destroy__ = _Extrema.delete_Extrema_SequenceOfPOnCurv2d

# Register Extrema_SequenceOfPOnCurv2d in _Extrema:
_Extrema.Extrema_SequenceOfPOnCurv2d_swigregister(Extrema_SequenceOfPOnCurv2d)
Extrema_SequenceOfPOnCurv2d_delNode = _Extrema.Extrema_SequenceOfPOnCurv2d_delNode

class Extrema_UBTreeOfSphere(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):
        _Extrema.Extrema_UBTreeOfSphere_swiginit(self, _Extrema.new_Extrema_UBTreeOfSphere(*args))
    Add = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_Add)
    Select = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_Select)
    Clear = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_Clear)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_IsEmpty)
    Root = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_Root)
    __swig_destroy__ = _Extrema.delete_Extrema_UBTreeOfSphere
    Allocator = _swig_new_instance_method(_Extrema.Extrema_UBTreeOfSphere_Allocator)

# Register Extrema_UBTreeOfSphere in _Extrema:
_Extrema.Extrema_UBTreeOfSphere_swigregister(Extrema_UBTreeOfSphere)

class Extrema_UBTreeFillerOfSphere(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):
        _Extrema.Extrema_UBTreeFillerOfSphere_swiginit(self, _Extrema.new_Extrema_UBTreeFillerOfSphere(*args))
    Add = _swig_new_instance_method(_Extrema.Extrema_UBTreeFillerOfSphere_Add)
    Fill = _swig_new_instance_method(_Extrema.Extrema_UBTreeFillerOfSphere_Fill)
    Reset = _swig_new_instance_method(_Extrema.Extrema_UBTreeFillerOfSphere_Reset)
    CheckTree = _swig_new_instance_method(_Extrema.Extrema_UBTreeFillerOfSphere_CheckTree)
    __swig_destroy__ = _Extrema.delete_Extrema_UBTreeFillerOfSphere

# Register Extrema_UBTreeFillerOfSphere in _Extrema:
_Extrema.Extrema_UBTreeFillerOfSphere_swigregister(Extrema_UBTreeFillerOfSphere)

class Extrema_Array2OfPOnCurv(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):
        _Extrema.Extrema_Array2OfPOnCurv_swiginit(self, _Extrema.new_Extrema_Array2OfPOnCurv(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Length)
    NbRows = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_NbRows)
    NbColumns = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_NbColumns)
    RowLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_RowLength)
    ColLength = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_ColLength)
    LowerRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_LowerRow)
    UpperRow = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_UpperRow)
    LowerCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_LowerCol)
    UpperCol = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_UpperCol)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_IsDeletable)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Set)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array2OfPOnCurv_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array2OfPOnCurv

# Register Extrema_Array2OfPOnCurv in _Extrema:
_Extrema.Extrema_Array2OfPOnCurv_swigregister(Extrema_Array2OfPOnCurv)

class Extrema_Array1OfPOnSurf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_begin)
    end = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_end)
    cbegin = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_cbegin)
    cend = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_cend)

    def __init__(self, *args):
        _Extrema.Extrema_Array1OfPOnSurf_swiginit(self, _Extrema.new_Extrema_Array1OfPOnSurf(*args))
    Init = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Init)
    Size = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Size)
    Length = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Length)
    IsEmpty = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_IsEmpty)
    Lower = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Lower)
    Upper = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Upper)
    IsDeletable = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_IsDeletable)
    IsAllocated = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_IsAllocated)
    Assign = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Assign)
    Move = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Move)
    Set = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Set)
    First = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_First)
    ChangeFirst = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_ChangeFirst)
    Last = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Last)
    ChangeLast = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_ChangeLast)
    Value = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Value)
    ChangeValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_ChangeValue)
    __call__ = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf___call__)
    SetValue = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_SetValue)
    Resize = _swig_new_instance_method(_Extrema.Extrema_Array1OfPOnSurf_Resize)
    __swig_destroy__ = _Extrema.delete_Extrema_Array1OfPOnSurf

    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 Extrema_Array1OfPOnSurf in _Extrema:
_Extrema.Extrema_Array1OfPOnSurf_swigregister(Extrema_Array1OfPOnSurf)

class Extrema_CCLocFOfLocECC(OCC.Core.math.math_FunctionSetWithDerivatives):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CurvePtr = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_CurvePtr)

    def __init__(self, *args):
        r"""
        :param thetol: default value is 1.0e-10
        	:type thetol: float
        	:rtype: None:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param thetol: default value is 1.0e-10
        	:type thetol: float
        	:rtype: None
        """
        _Extrema.Extrema_CCLocFOfLocECC_swiginit(self, _Extrema.new_Extrema_CCLocFOfLocECC(*args))
    NbExt = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_NbExt)
    Points = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_Points)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_SearchOfTolerance)
    SetCurve = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_SetCurve)
    SetTolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_SetTolerance)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_SubIntervalInitialize)
    Tolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC_Tolerance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_CCLocFOfLocECC

# Register Extrema_CCLocFOfLocECC in _Extrema:
_Extrema.Extrema_CCLocFOfLocECC_swigregister(Extrema_CCLocFOfLocECC)

class Extrema_CCLocFOfLocECC2d(OCC.Core.math.math_FunctionSetWithDerivatives):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CurvePtr = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_CurvePtr)

    def __init__(self, *args):
        r"""
        :param thetol: default value is 1.0e-10
        	:type thetol: float
        	:rtype: None:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param thetol: default value is 1.0e-10
        	:type thetol: float
        	:rtype: None
        """
        _Extrema.Extrema_CCLocFOfLocECC2d_swiginit(self, _Extrema.new_Extrema_CCLocFOfLocECC2d(*args))
    NbExt = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_NbExt)
    Points = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_Points)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_SearchOfTolerance)
    SetCurve = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_SetCurve)
    SetTolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_SetTolerance)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_SubIntervalInitialize)
    Tolerance = _swig_new_instance_method(_Extrema.Extrema_CCLocFOfLocECC2d_Tolerance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_CCLocFOfLocECC2d

# Register Extrema_CCLocFOfLocECC2d in _Extrema:
_Extrema.Extrema_CCLocFOfLocECC2d_swigregister(Extrema_CCLocFOfLocECC2d)

class Extrema_Curve2dTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BSpline = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_BSpline)
    Bezier = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Bezier)
    Circle = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Circle)
    Continuity = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Continuity)
    D0 = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_D0)
    D1 = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_D1)
    D2 = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_D2)
    D3 = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_D3)
    DN = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_DN)
    DeflCurvIntervals = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_DeflCurvIntervals)
    Degree = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Degree)
    Ellipse = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Ellipse)
    FirstParameter = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_FirstParameter)
    GetType = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_GetType)
    Hyperbola = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Hyperbola)
    Intervals = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Intervals)
    IsClosed = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_IsClosed)
    IsPeriodic = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_IsPeriodic)
    IsRational = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_IsRational)
    LastParameter = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_LastParameter)
    Line = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Line)
    NbIntervals = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_NbIntervals)
    NbKnots = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_NbKnots)
    NbPoles = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_NbPoles)
    Parabola = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Parabola)
    Period = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Period)
    Resolution = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Resolution)
    Value = _swig_new_static_method(_Extrema.Extrema_Curve2dTool_Value)

    __repr__ = _dumps_object


    def __init__(self):
        _Extrema.Extrema_Curve2dTool_swiginit(self, _Extrema.new_Extrema_Curve2dTool())
    __swig_destroy__ = _Extrema.delete_Extrema_Curve2dTool

# Register Extrema_Curve2dTool in _Extrema:
_Extrema.Extrema_Curve2dTool_swigregister(Extrema_Curve2dTool)
Extrema_Curve2dTool_BSpline = _Extrema.Extrema_Curve2dTool_BSpline
Extrema_Curve2dTool_Bezier = _Extrema.Extrema_Curve2dTool_Bezier
Extrema_Curve2dTool_Circle = _Extrema.Extrema_Curve2dTool_Circle
Extrema_Curve2dTool_Continuity = _Extrema.Extrema_Curve2dTool_Continuity
Extrema_Curve2dTool_D0 = _Extrema.Extrema_Curve2dTool_D0
Extrema_Curve2dTool_D1 = _Extrema.Extrema_Curve2dTool_D1
Extrema_Curve2dTool_D2 = _Extrema.Extrema_Curve2dTool_D2
Extrema_Curve2dTool_D3 = _Extrema.Extrema_Curve2dTool_D3
Extrema_Curve2dTool_DN = _Extrema.Extrema_Curve2dTool_DN
Extrema_Curve2dTool_DeflCurvIntervals = _Extrema.Extrema_Curve2dTool_DeflCurvIntervals
Extrema_Curve2dTool_Degree = _Extrema.Extrema_Curve2dTool_Degree
Extrema_Curve2dTool_Ellipse = _Extrema.Extrema_Curve2dTool_Ellipse
Extrema_Curve2dTool_FirstParameter = _Extrema.Extrema_Curve2dTool_FirstParameter
Extrema_Curve2dTool_GetType = _Extrema.Extrema_Curve2dTool_GetType
Extrema_Curve2dTool_Hyperbola = _Extrema.Extrema_Curve2dTool_Hyperbola
Extrema_Curve2dTool_Intervals = _Extrema.Extrema_Curve2dTool_Intervals
Extrema_Curve2dTool_IsClosed = _Extrema.Extrema_Curve2dTool_IsClosed
Extrema_Curve2dTool_IsPeriodic = _Extrema.Extrema_Curve2dTool_IsPeriodic
Extrema_Curve2dTool_IsRational = _Extrema.Extrema_Curve2dTool_IsRational
Extrema_Curve2dTool_LastParameter = _Extrema.Extrema_Curve2dTool_LastParameter
Extrema_Curve2dTool_Line = _Extrema.Extrema_Curve2dTool_Line
Extrema_Curve2dTool_NbIntervals = _Extrema.Extrema_Curve2dTool_NbIntervals
Extrema_Curve2dTool_NbKnots = _Extrema.Extrema_Curve2dTool_NbKnots
Extrema_Curve2dTool_NbPoles = _Extrema.Extrema_Curve2dTool_NbPoles
Extrema_Curve2dTool_Parabola = _Extrema.Extrema_Curve2dTool_Parabola
Extrema_Curve2dTool_Period = _Extrema.Extrema_Curve2dTool_Period
Extrema_Curve2dTool_Resolution = _Extrema.Extrema_Curve2dTool_Resolution
Extrema_Curve2dTool_Value = _Extrema.Extrema_Curve2dTool_Value

class Extrema_CurveTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BSpline = _swig_new_static_method(_Extrema.Extrema_CurveTool_BSpline)
    Bezier = _swig_new_static_method(_Extrema.Extrema_CurveTool_Bezier)
    Circle = _swig_new_static_method(_Extrema.Extrema_CurveTool_Circle)
    Continuity = _swig_new_static_method(_Extrema.Extrema_CurveTool_Continuity)
    D0 = _swig_new_static_method(_Extrema.Extrema_CurveTool_D0)
    D1 = _swig_new_static_method(_Extrema.Extrema_CurveTool_D1)
    D2 = _swig_new_static_method(_Extrema.Extrema_CurveTool_D2)
    D3 = _swig_new_static_method(_Extrema.Extrema_CurveTool_D3)
    DN = _swig_new_static_method(_Extrema.Extrema_CurveTool_DN)
    DeflCurvIntervals = _swig_new_static_method(_Extrema.Extrema_CurveTool_DeflCurvIntervals)
    Degree = _swig_new_static_method(_Extrema.Extrema_CurveTool_Degree)
    Ellipse = _swig_new_static_method(_Extrema.Extrema_CurveTool_Ellipse)
    FirstParameter = _swig_new_static_method(_Extrema.Extrema_CurveTool_FirstParameter)
    GetType = _swig_new_static_method(_Extrema.Extrema_CurveTool_GetType)
    Hyperbola = _swig_new_static_method(_Extrema.Extrema_CurveTool_Hyperbola)
    Intervals = _swig_new_static_method(_Extrema.Extrema_CurveTool_Intervals)
    IsPeriodic = _swig_new_static_method(_Extrema.Extrema_CurveTool_IsPeriodic)
    IsRational = _swig_new_static_method(_Extrema.Extrema_CurveTool_IsRational)
    LastParameter = _swig_new_static_method(_Extrema.Extrema_CurveTool_LastParameter)
    Line = _swig_new_static_method(_Extrema.Extrema_CurveTool_Line)
    NbIntervals = _swig_new_static_method(_Extrema.Extrema_CurveTool_NbIntervals)
    NbKnots = _swig_new_static_method(_Extrema.Extrema_CurveTool_NbKnots)
    NbPoles = _swig_new_static_method(_Extrema.Extrema_CurveTool_NbPoles)
    Parabola = _swig_new_static_method(_Extrema.Extrema_CurveTool_Parabola)
    Period = _swig_new_static_method(_Extrema.Extrema_CurveTool_Period)
    Resolution = _swig_new_static_method(_Extrema.Extrema_CurveTool_Resolution)
    Value = _swig_new_static_method(_Extrema.Extrema_CurveTool_Value)

    __repr__ = _dumps_object


    def __init__(self):
        _Extrema.Extrema_CurveTool_swiginit(self, _Extrema.new_Extrema_CurveTool())
    __swig_destroy__ = _Extrema.delete_Extrema_CurveTool

# Register Extrema_CurveTool in _Extrema:
_Extrema.Extrema_CurveTool_swigregister(Extrema_CurveTool)
Extrema_CurveTool_BSpline = _Extrema.Extrema_CurveTool_BSpline
Extrema_CurveTool_Bezier = _Extrema.Extrema_CurveTool_Bezier
Extrema_CurveTool_Circle = _Extrema.Extrema_CurveTool_Circle
Extrema_CurveTool_Continuity = _Extrema.Extrema_CurveTool_Continuity
Extrema_CurveTool_D0 = _Extrema.Extrema_CurveTool_D0
Extrema_CurveTool_D1 = _Extrema.Extrema_CurveTool_D1
Extrema_CurveTool_D2 = _Extrema.Extrema_CurveTool_D2
Extrema_CurveTool_D3 = _Extrema.Extrema_CurveTool_D3
Extrema_CurveTool_DN = _Extrema.Extrema_CurveTool_DN
Extrema_CurveTool_DeflCurvIntervals = _Extrema.Extrema_CurveTool_DeflCurvIntervals
Extrema_CurveTool_Degree = _Extrema.Extrema_CurveTool_Degree
Extrema_CurveTool_Ellipse = _Extrema.Extrema_CurveTool_Ellipse
Extrema_CurveTool_FirstParameter = _Extrema.Extrema_CurveTool_FirstParameter
Extrema_CurveTool_GetType = _Extrema.Extrema_CurveTool_GetType
Extrema_CurveTool_Hyperbola = _Extrema.Extrema_CurveTool_Hyperbola
Extrema_CurveTool_Intervals = _Extrema.Extrema_CurveTool_Intervals
Extrema_CurveTool_IsPeriodic = _Extrema.Extrema_CurveTool_IsPeriodic
Extrema_CurveTool_IsRational = _Extrema.Extrema_CurveTool_IsRational
Extrema_CurveTool_LastParameter = _Extrema.Extrema_CurveTool_LastParameter
Extrema_CurveTool_Line = _Extrema.Extrema_CurveTool_Line
Extrema_CurveTool_NbIntervals = _Extrema.Extrema_CurveTool_NbIntervals
Extrema_CurveTool_NbKnots = _Extrema.Extrema_CurveTool_NbKnots
Extrema_CurveTool_NbPoles = _Extrema.Extrema_CurveTool_NbPoles
Extrema_CurveTool_Parabola = _Extrema.Extrema_CurveTool_Parabola
Extrema_CurveTool_Period = _Extrema.Extrema_CurveTool_Period
Extrema_CurveTool_Resolution = _Extrema.Extrema_CurveTool_Resolution
Extrema_CurveTool_Value = _Extrema.Extrema_CurveTool_Value

class Extrema_ECC(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"""
        * Calculates all the distances as above between Uinf and Usup for C1 and between Vinf and Vsup for C2.
        	:rtype: None* It calculates all the distances. The function F(u,v)=distance(C1(u),C2(v)) has an extremum when gradient(f)=0. The algorithm uses Evtushenko's global optimization solver.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:rtype: None* Calculates all the distances as above between Uinf and Usup for C1 and between Vinf and Vsup for C2.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param Vinf:
        	:type Vinf: float
        	:param Vsup:
        	:type Vsup: float
        	:rtype: None
        """
        _Extrema.Extrema_ECC_swiginit(self, _Extrema.new_Extrema_ECC(*args))
    GetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ECC_GetSingleSolutionFlag)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ECC_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ECC_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ECC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ECC_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ECC_Points)
    SetParams = _swig_new_instance_method(_Extrema.Extrema_ECC_SetParams)
    SetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ECC_SetSingleSolutionFlag)
    SetTolerance = _swig_new_instance_method(_Extrema.Extrema_ECC_SetTolerance)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ECC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ECC

# Register Extrema_ECC in _Extrema:
_Extrema.Extrema_ECC_swigregister(Extrema_ECC)

class Extrema_ECC2d(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"""
        * Calculates all the distances as above between Uinf and Usup for C1 and between Vinf and Vsup for C2.
        	:rtype: None* It calculates all the distances. The function F(u,v)=distance(C1(u),C2(v)) has an extremum when gradient(f)=0. The algorithm uses Evtushenko's global optimization solver.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:rtype: None* Calculates all the distances as above between Uinf and Usup for C1 and between Vinf and Vsup for C2.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param Vinf:
        	:type Vinf: float
        	:param Vsup:
        	:type Vsup: float
        	:rtype: None
        """
        _Extrema.Extrema_ECC2d_swiginit(self, _Extrema.new_Extrema_ECC2d(*args))
    GetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ECC2d_GetSingleSolutionFlag)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ECC2d_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ECC2d_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ECC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ECC2d_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ECC2d_Points)
    SetParams = _swig_new_instance_method(_Extrema.Extrema_ECC2d_SetParams)
    SetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ECC2d_SetSingleSolutionFlag)
    SetTolerance = _swig_new_instance_method(_Extrema.Extrema_ECC2d_SetTolerance)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ECC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ECC2d

# Register Extrema_ECC2d in _Extrema:
_Extrema.Extrema_ECC2d_swigregister(Extrema_ECC2d)

class Extrema_ELPCOfLocateExtPC(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Zeros are searched between uinf and usup. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_ELPCOfLocateExtPC_swiginit(self, _Extrema.new_Extrema_ELPCOfLocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ELPCOfLocateExtPC

# Register Extrema_ELPCOfLocateExtPC in _Extrema:
_Extrema.Extrema_ELPCOfLocateExtPC_swigregister(Extrema_ELPCOfLocateExtPC)

class Extrema_ELPCOfLocateExtPC2d(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Zeros are searched between uinf and usup. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_ELPCOfLocateExtPC2d_swiginit(self, _Extrema.new_Extrema_ELPCOfLocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ELPCOfLocateExtPC2d_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ELPCOfLocateExtPC2d

# Register Extrema_ELPCOfLocateExtPC2d in _Extrema:
_Extrema.Extrema_ELPCOfLocateExtPC2d_swigregister(Extrema_ELPCOfLocateExtPC2d)

class Extrema_EPCOfELPCOfLocateExtPC(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param NbU:
        	:type NbU: int
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Zeros are searched between umin and usup. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param NbU:
        	:type NbU: int
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_EPCOfELPCOfLocateExtPC_swiginit(self, _Extrema.new_Extrema_EPCOfELPCOfLocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_EPCOfELPCOfLocateExtPC

# Register Extrema_EPCOfELPCOfLocateExtPC in _Extrema:
_Extrema.Extrema_EPCOfELPCOfLocateExtPC_swigregister(Extrema_EPCOfELPCOfLocateExtPC)

class Extrema_EPCOfELPCOfLocateExtPC2d(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param NbU:
        	:type NbU: int
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Zeros are searched between umin and usup. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param NbU:
        	:type NbU: int
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_swiginit(self, _Extrema.new_Extrema_EPCOfELPCOfLocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_EPCOfELPCOfLocateExtPC2d

# Register Extrema_EPCOfELPCOfLocateExtPC2d in _Extrema:
_Extrema.Extrema_EPCOfELPCOfLocateExtPC2d_swigregister(Extrema_EPCOfELPCOfLocateExtPC2d)

class Extrema_EPCOfExtPC(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param NbU:
        	:type NbU: int
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Zeros are searched between umin and usup. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param NbU:
        	:type NbU: int
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_EPCOfExtPC_swiginit(self, _Extrema.new_Extrema_EPCOfExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_EPCOfExtPC

# Register Extrema_EPCOfExtPC in _Extrema:
_Extrema.Extrema_EPCOfExtPC_swigregister(Extrema_EPCOfExtPC)

class Extrema_EPCOfExtPC2d(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param NbU:
        	:type NbU: int
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. NbU is used to locate the close points to find the zeros. Zeros are searched between umin and usup. Tol and TolU are used to decide to stop the iterations according to the following condition: if n is the number of iterations, abs(Un-Un-1) < TolU and abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param NbU:
        	:type NbU: int
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_EPCOfExtPC2d_swiginit(self, _Extrema.new_Extrema_EPCOfExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_EPCOfExtPC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_EPCOfExtPC2d

# Register Extrema_EPCOfExtPC2d in _Extrema:
_Extrema.Extrema_EPCOfExtPC2d_swigregister(Extrema_EPCOfExtPC2d)

class Extrema_ExtCC(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"""
        :param TolC1: default value is 1.0e-10
        	:type TolC1: float
        	:param TolC2: default value is 1.0e-10
        	:type TolC2: float
        	:rtype: None* It calculates all the distances.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param TolC1: default value is 1.0e-10
        	:type TolC1: float
        	:param TolC2: default value is 1.0e-10
        	:type TolC2: float
        	:rtype: None* It calculates all the distances.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param U1:
        	:type U1: float
        	:param U2:
        	:type U2: float
        	:param V1:
        	:type V1: float
        	:param V2:
        	:type V2: float
        	:param TolC1: default value is 1.0e-10
        	:type TolC1: float
        	:param TolC2: default value is 1.0e-10
        	:type TolC2: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtCC_swiginit(self, _Extrema.new_Extrema_ExtCC(*args))
    GetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ExtCC_GetSingleSolutionFlag)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtCC_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtCC_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtCC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtCC_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtCC_Points)
    SetCurve = _swig_new_instance_method(_Extrema.Extrema_ExtCC_SetCurve)
    SetRange = _swig_new_instance_method(_Extrema.Extrema_ExtCC_SetRange)
    SetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ExtCC_SetSingleSolutionFlag)
    SetTolerance = _swig_new_instance_method(_Extrema.Extrema_ExtCC_SetTolerance)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtCC_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ExtCC_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtCC

# Register Extrema_ExtCC in _Extrema:
_Extrema.Extrema_ExtCC_swigregister(Extrema_ExtCC)

class Extrema_ExtCC2d(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"""
        :rtype: None* It calculates all the distances.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param TolC1: default value is 1.0e-10
        	:type TolC1: float
        	:param TolC2: default value is 1.0e-10
        	:type TolC2: float
        	:rtype: None* It calculates all the distances.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param U1:
        	:type U1: float
        	:param U2:
        	:type U2: float
        	:param V1:
        	:type V1: float
        	:param V2:
        	:type V2: float
        	:param TolC1: default value is 1.0e-10
        	:type TolC1: float
        	:param TolC2: default value is 1.0e-10
        	:type TolC2: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtCC2d_swiginit(self, _Extrema.new_Extrema_ExtCC2d(*args))
    GetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_GetSingleSolutionFlag)
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_Points)
    SetSingleSolutionFlag = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_SetSingleSolutionFlag)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ExtCC2d_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtCC2d

# Register Extrema_ExtCC2d in _Extrema:
_Extrema.Extrema_ExtCC2d_swigregister(Extrema_ExtCC2d)

class Extrema_ExtCS(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"""
        :rtype: None* It calculates all the distances between C and S.
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param TolC:
        	:type TolC: float
        	:param TolS:
        	:type TolS: float
        	:rtype: None* It calculates all the distances between C and S. UCinf and UCmax are the start and end parameters of the curve.
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param UCinf:
        	:type UCinf: float
        	:param UCsup:
        	:type UCsup: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param Vinf:
        	:type Vinf: float
        	:param Vsup:
        	:type Vsup: float
        	:param TolC:
        	:type TolC: float
        	:param TolS:
        	:type TolS: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtCS_swiginit(self, _Extrema.new_Extrema_ExtCS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtCS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtCS_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtCS_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtCS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtCS_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtCS_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtCS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtCS

# Register Extrema_ExtCS in _Extrema:
_Extrema.Extrema_ExtCS_swigregister(Extrema_ExtCS)

class Extrema_ExtElC(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"""
        :rtype: None* Calculates the distance between two lines. AngTol is used to test if the lines are parallel: Angle(C1,C2) < AngTol.
        	:param C1:
        	:type C1: gp_Lin
        	:param C2:
        	:type C2: gp_Lin
        	:param AngTol:
        	:type AngTol: float
        	:rtype: None* Calculates the distance between a line and a circle.
        	:param C1:
        	:type C1: gp_Lin
        	:param C2:
        	:type C2: gp_Circ
        	:param Tol:
        	:type Tol: float
        	:rtype: None* Calculates the distance between a line and an elipse.
        	:param C1:
        	:type C1: gp_Lin
        	:param C2:
        	:type C2: gp_Elips
        	:rtype: None* Calculates the distance between a line and a hyperbola.
        	:param C1:
        	:type C1: gp_Lin
        	:param C2:
        	:type C2: gp_Hypr
        	:rtype: None* Calculates the distance between a line and a parabola.
        	:param C1:
        	:type C1: gp_Lin
        	:param C2:
        	:type C2: gp_Parab
        	:rtype: None* Calculates the distance between two circles. The circles can be parallel or identical.
        	:param C1:
        	:type C1: gp_Circ
        	:param C2:
        	:type C2: gp_Circ
        	:rtype: None
        """
        _Extrema.Extrema_ExtElC_swiginit(self, _Extrema.new_Extrema_ExtElC(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtElC_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtElC_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtElC_NbExt)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtElC_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtElC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtElC

# Register Extrema_ExtElC in _Extrema:
_Extrema.Extrema_ExtElC_swigregister(Extrema_ExtElC)

class Extrema_ExtElC2d(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"""
        :rtype: None* Calculates the distance between two lines. AngTol is used to test if the lines are parallel: Angle(C1,C2) < AngTol.
        	:param C1:
        	:type C1: gp_Lin2d
        	:param C2:
        	:type C2: gp_Lin2d
        	:param AngTol:
        	:type AngTol: float
        	:rtype: None* Calculates the distance between a line and a circle.
        	:param C1:
        	:type C1: gp_Lin2d
        	:param C2:
        	:type C2: gp_Circ2d
        	:param Tol:
        	:type Tol: float
        	:rtype: None* Calculates the distance between a line and an elipse.
        	:param C1:
        	:type C1: gp_Lin2d
        	:param C2:
        	:type C2: gp_Elips2d
        	:rtype: None* Calculates the distance between a line and a hyperbola.
        	:param C1:
        	:type C1: gp_Lin2d
        	:param C2:
        	:type C2: gp_Hypr2d
        	:rtype: None* Calculates the distance between a line and a parabola.
        	:param C1:
        	:type C1: gp_Lin2d
        	:param C2:
        	:type C2: gp_Parab2d
        	:rtype: None* Calculates the distance between two circles. The circles can be parallel or identical.
        	:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: gp_Circ2d
        	:rtype: None* Calculates the distance between a circle and an elipse.
        	:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: gp_Elips2d
        	:rtype: None* Calculates the distance between a circle and a hyperbola.
        	:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: gp_Hypr2d
        	:rtype: None* Calculates the distance between a circle and a parabola.
        	:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: gp_Parab2d
        	:rtype: None
        """
        _Extrema.Extrema_ExtElC2d_swiginit(self, _Extrema.new_Extrema_ExtElC2d(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtElC2d_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtElC2d_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtElC2d_NbExt)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtElC2d_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtElC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtElC2d

# Register Extrema_ExtElC2d in _Extrema:
_Extrema.Extrema_ExtElC2d_swigregister(Extrema_ExtElC2d)

class Extrema_ExtElCS(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"""
        :rtype: None* Calculates the distances between a line and a plane. The line can be on the plane or on a parallel plane.
        	:param C:
        	:type C: gp_Lin
        	:param S:
        	:type S: gp_Pln
        	:rtype: None* Calculates the distances between a line and a cylinder.
        	:param C:
        	:type C: gp_Lin
        	:param S:
        	:type S: gp_Cylinder
        	:rtype: None* Calculates the distances between a line and a cone.
        	:param C:
        	:type C: gp_Lin
        	:param S:
        	:type S: gp_Cone
        	:rtype: None* Calculates the distances between a line and a sphere.
        	:param C:
        	:type C: gp_Lin
        	:param S:
        	:type S: gp_Sphere
        	:rtype: None* Calculates the distances between a line and a torus.
        	:param C:
        	:type C: gp_Lin
        	:param S:
        	:type S: gp_Torus
        	:rtype: None* Calculates the distances between a circle and a plane.
        	:param C:
        	:type C: gp_Circ
        	:param S:
        	:type S: gp_Pln
        	:rtype: None* Calculates the distances between a circle and a cylinder.
        	:param C:
        	:type C: gp_Circ
        	:param S:
        	:type S: gp_Cylinder
        	:rtype: None* Calculates the distances between a circle and a cone.
        	:param C:
        	:type C: gp_Circ
        	:param S:
        	:type S: gp_Cone
        	:rtype: None* Calculates the distances between a circle and a sphere.
        	:param C:
        	:type C: gp_Circ
        	:param S:
        	:type S: gp_Sphere
        	:rtype: None* Calculates the distances between a circle and a torus.
        	:param C:
        	:type C: gp_Circ
        	:param S:
        	:type S: gp_Torus
        	:rtype: None* Calculates the distances between a hyperbola and a plane.
        	:param C:
        	:type C: gp_Hypr
        	:param S:
        	:type S: gp_Pln
        	:rtype: None
        """
        _Extrema.Extrema_ExtElCS_swiginit(self, _Extrema.new_Extrema_ExtElCS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtElCS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtElCS

# Register Extrema_ExtElCS in _Extrema:
_Extrema.Extrema_ExtElCS_swigregister(Extrema_ExtElCS)

class Extrema_ExtElSS(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"""
        :rtype: None* Calculates the distances between 2 planes. These planes can be parallel.
        	:param S1:
        	:type S1: gp_Pln
        	:param S2:
        	:type S2: gp_Pln
        	:rtype: None* Calculates the distances between a plane and a sphere.
        	:param S1:
        	:type S1: gp_Pln
        	:param S2:
        	:type S2: gp_Sphere
        	:rtype: None* Calculates the distances between 2 spheres. These spheres can be parallel.
        	:param S1:
        	:type S1: gp_Sphere
        	:param S2:
        	:type S2: gp_Sphere
        	:rtype: None* Calculates the distances between a sphere and a cylinder.
        	:param S1:
        	:type S1: gp_Sphere
        	:param S2:
        	:type S2: gp_Cylinder
        	:rtype: None* Calculates the distances between a sphere and a cone.
        	:param S1:
        	:type S1: gp_Sphere
        	:param S2:
        	:type S2: gp_Cone
        	:rtype: None* Calculates the distances between a sphere and a torus.
        	:param S1:
        	:type S1: gp_Sphere
        	:param S2:
        	:type S2: gp_Torus
        	:rtype: None
        """
        _Extrema.Extrema_ExtElSS_swiginit(self, _Extrema.new_Extrema_ExtElSS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtElSS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtElSS

# Register Extrema_ExtElSS in _Extrema:
_Extrema.Extrema_ExtElSS_swigregister(Extrema_ExtElSS)

class Extrema_ExtPC(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Zeros are searched between uinf and usup. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPC_swiginit(self, _Extrema.new_Extrema_ExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPC_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ExtPC_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPC

# Register Extrema_ExtPC in _Extrema:
_Extrema.Extrema_ExtPC_swigregister(Extrema_ExtPC)

class Extrema_ExtPC2d(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"""
        :rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Zeros are searched between uinf and usup. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None* It calculates all the distances. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs all the zeros inside the definition range of the curve. Tol is used to decide to stop the iterations according to the following condition: if n is the number of iterations, the algorithm stops when abs(F(Un)-F(Un-1)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param TolF: default value is 1.0e-10
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPC2d_swiginit(self, _Extrema.new_Extrema_ExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ExtPC2d_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPC2d

# Register Extrema_ExtPC2d in _Extrema:
_Extrema.Extrema_ExtPC2d_swigregister(Extrema_ExtPC2d)

class Extrema_ExtPElC(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"""
        :rtype: None* Calculates the extremum distance between the point P and the segment [Uinf,Usup] of the line C.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: gp_Lin
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 2 extremum distances between the point P and the segment [Uinf,Usup] of the circle C. Tol is used to determine if P is on the axis of the circle or if an extremum is on an endpoint of the segment. If P is on the axis of the circle, there are infinite solution then IsDone(me)=False. The conditions on the Uinf and Usup are: 0. <= Uinf <= 2.*PI and Usup > Uinf. If Usup > Uinf + 2.*PI, then only the solutions in the range [Uinf,Uinf+2.*PI[ are computed.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: gp_Circ
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 4 extremum distances between the point P and the segment [Uinf,Usup] of the elipse C. Tol is used to determine if the point is on the axis of the elipse and if the major radius is equal to the minor radius or if an extremum is on an endpoint of the segment. If P is on the axis of the elipse, there are infinite solution then IsDone(me)=False. The conditions on the Uinf and Usup are: 0. <= Uinf <= 2.*PI and Usup > Uinf. If Usup > Uinf + 2.*PI, then only the solutions in the range [Uinf,Uinf+2.*PI[ are computed.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: gp_Elips
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the extremum distances between the point P and the segment [Uinf,Usup] of the hyperbola C. Tol is used to determine if two solutions u and v are identical; the condition is: dist(C(u),C(v)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: gp_Hypr
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 4 extremum distances between the point P and the segment [Uinf,Usup] of the parabola C. Tol is used to determine if two solutions u and v are identical; the condition is: dist(C(u),C(v)) < Tol.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: gp_Parab
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPElC_swiginit(self, _Extrema.new_Extrema_ExtPElC(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPElC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPElC

# Register Extrema_ExtPElC in _Extrema:
_Extrema.Extrema_ExtPElC_swigregister(Extrema_ExtPElC)

class Extrema_ExtPElC2d(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"""
        :rtype: None* Calculates the extremum distance between the point P and the segment [Uinf,Usup] of the line L.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: gp_Lin2d
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 2 extremum distances between the point P and the segment [Uinf,Usup] of the circle C. Tol is used to determine if P is on the axis of the circle or if an extremum is on an endpoint of the segment. If P is on the axis of the circle, there are infinite solution then IsDone(me)=False. The conditions on the Uinf and Usup are: 0. <= Uinf <= 2.*PI and Usup > Uinf. If Usup > Uinf + 2.*PI, then only the solutions in the range [Uinf,Uinf+2.*PI[ are computed.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: gp_Circ2d
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 4 extremum distances between the point P and the segment [Uinf,Usup] of the elipse C. Tol is used to determine if the point is on the axis of the elipse and if the major radius is equal to the minor radius or if an extremum is on an endpoint of the segment. If P is on the axis of the elipse, there are infinite solution then IsDone(me)=False. The conditions on the Uinf and Usup are: 0. <= Uinf <= 2.*PI and Usup > Uinf. If Usup > Uinf + 2.*PI, then only the solutions in the range [Uinf,Uinf+2.*PI[ are computed.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: gp_Elips2d
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the extremum distances between the point P and the segment [Uinf,Usup] of the hyperbola C. Tol is used to determine if two solutions u and v are identical; the condition is: dist(C(u),C(v)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: gp_Hypr2d
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None* Calculates the 4 extremum distances between the point P and the segment [Uinf,Usup] of the parabola C. Tol is used to determine if two solutions u and v are identical; the condition is: dist(C(u),C(v)) < Tol.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: gp_Parab2d
        	:param Tol:
        	:type Tol: float
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPElC2d_swiginit(self, _Extrema.new_Extrema_ExtPElC2d(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPElC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPElC2d

# Register Extrema_ExtPElC2d in _Extrema:
_Extrema.Extrema_ExtPElC2d_swigregister(Extrema_ExtPElC2d)

class Extrema_ExtPElS(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"""
        :rtype: None* It calculates all the distances between a point and a cylinder from gp. Tol is used to test if the point is on the axis.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: gp_Cylinder
        	:param Tol:
        	:type Tol: float
        	:rtype: None* It calculates all the distances between a point and a plane from gp. Tol is used to test if the point is on the plane.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: gp_Pln
        	:param Tol:
        	:type Tol: float
        	:rtype: None* It calculates all the distances between a point and a cone from gp. Tol is used to test if the point is at the apex or on the axis.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: gp_Cone
        	:param Tol:
        	:type Tol: float
        	:rtype: None* It calculates all the distances between a point and a torus from gp. Tol is used to test if the point is on the axis.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: gp_Torus
        	:param Tol:
        	:type Tol: float
        	:rtype: None* It calculates all the distances between a point and a sphere from gp. Tol is used to test if the point is at the center.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: gp_Sphere
        	:param Tol:
        	:type Tol: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPElS_swiginit(self, _Extrema.new_Extrema_ExtPElS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPElS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPElS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPElS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPElS_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPElS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPElS

# Register Extrema_ExtPElS in _Extrema:
_Extrema.Extrema_ExtPElS_swigregister(Extrema_ExtPElS)

class Extrema_ExtPExtS(OCC.Core.Standard.Standard_Transient):
    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"""
        :rtype: None* It calculates all the distances between a point from gp and a Surface.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: GeomAdaptor_HSurfaceOfLinearExtrusion
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param Vmin:
        	:type Vmin: float
        	:param Vsup:
        	:type Vsup: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None* It calculates all the distances between a point from gp and a Surface.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: GeomAdaptor_HSurfaceOfLinearExtrusion
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPExtS_swiginit(self, _Extrema.new_Extrema_ExtPExtS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPExtS_SquareDistance)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPExtS

# Register Extrema_ExtPExtS in _Extrema:
_Extrema.Extrema_ExtPExtS_swigregister(Extrema_ExtPExtS)

class Extrema_ExtPRevS(OCC.Core.Standard.Standard_Transient):
    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"""
        :rtype: None* It calculates all the distances between a point from gp and a SurfacePtr from Adaptor3d.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: GeomAdaptor_HSurfaceOfRevolution
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param Vmin:
        	:type Vmin: float
        	:param Vsup:
        	:type Vsup: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None* It calculates all the distances between a point from gp and a SurfacePtr from Adaptor3d.
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: GeomAdaptor_HSurfaceOfRevolution
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtPRevS_swiginit(self, _Extrema.new_Extrema_ExtPRevS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPRevS_SquareDistance)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPRevS

# Register Extrema_ExtPRevS in _Extrema:
_Extrema.Extrema_ExtPRevS_swigregister(Extrema_ExtPRevS)

class Extrema_ExtPS(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"""
        :rtype: None* It calculates all the distances. NbU and NbV are used to locate the close points to find the zeros. They must be great enough such that if there is N extrema, there will be N extrema between P and the grid. TolU et TolV are used to determine the conditions to stop the iterations; at the iteration number n: (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:param F: default value is Extrema_ExtFlag_MINMAX
        	:type F: Extrema_ExtFlag
        	:param A: default value is Extrema_ExtAlgo_Grad
        	:type A: Extrema_ExtAlgo
        	:rtype: None* It calculates all the distances. NbU and NbV are used to locate the close points to find the zeros. They must be great enough such that if there is N extrema, there will be N extrema between P and the grid. TolU et TolV are used to determine the conditions to stop the iterations; at the iteration number n: (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param Uinf:
        	:type Uinf: float
        	:param Usup:
        	:type Usup: float
        	:param Vinf:
        	:type Vinf: float
        	:param Vsup:
        	:type Vsup: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:param F: default value is Extrema_ExtFlag_MINMAX
        	:type F: Extrema_ExtFlag
        	:param A: default value is Extrema_ExtAlgo_Grad
        	:type A: Extrema_ExtAlgo
        	:rtype: None
        """
        _Extrema.Extrema_ExtPS_swiginit(self, _Extrema.new_Extrema_ExtPS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtPS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtPS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtPS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtPS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_ExtPS_Point)
    SetAlgo = _swig_new_instance_method(_Extrema.Extrema_ExtPS_SetAlgo)
    SetFlag = _swig_new_instance_method(_Extrema.Extrema_ExtPS_SetFlag)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtPS_SquareDistance)
    TrimmedSquareDistances = _swig_new_instance_method(_Extrema.Extrema_ExtPS_TrimmedSquareDistances)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtPS

# Register Extrema_ExtPS in _Extrema:
_Extrema.Extrema_ExtPS_swigregister(Extrema_ExtPS)

class Extrema_ExtSS(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"""
        :rtype: None* It calculates all the distances between S1 and S2.
        	:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:param TolS1:
        	:type TolS1: float
        	:param TolS2:
        	:type TolS2: float
        	:rtype: None* It calculates all the distances between S1 and S2.
        	:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:param Uinf1:
        	:type Uinf1: float
        	:param Usup1:
        	:type Usup1: float
        	:param Vinf1:
        	:type Vinf1: float
        	:param Vsup1:
        	:type Vsup1: float
        	:param Uinf2:
        	:type Uinf2: float
        	:param Usup2:
        	:type Usup2: float
        	:param Vinf2:
        	:type Vinf2: float
        	:param Vsup2:
        	:type Vsup2: float
        	:param TolS1:
        	:type TolS1: float
        	:param TolS2:
        	:type TolS2: float
        	:rtype: None
        """
        _Extrema.Extrema_ExtSS_swiginit(self, _Extrema.new_Extrema_ExtSS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_ExtSS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_ExtSS_IsDone)
    IsParallel = _swig_new_instance_method(_Extrema.Extrema_ExtSS_IsParallel)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_ExtSS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_ExtSS_Perform)
    Points = _swig_new_instance_method(_Extrema.Extrema_ExtSS_Points)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_ExtSS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_ExtSS

# Register Extrema_ExtSS in _Extrema:
_Extrema.Extrema_ExtSS_swigregister(Extrema_ExtSS)

class Extrema_FuncExtCS(OCC.Core.math.math_FunctionSetWithDerivatives):
    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"""
        :rtype: None:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:rtype: None
        """
        _Extrema.Extrema_FuncExtCS_swiginit(self, _Extrema.new_Extrema_FuncExtCS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_FuncExtCS_Initialize)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_FuncExtCS_NbExt)
    PointOnCurve = _swig_new_instance_method(_Extrema.Extrema_FuncExtCS_PointOnCurve)
    PointOnSurface = _swig_new_instance_method(_Extrema.Extrema_FuncExtCS_PointOnSurface)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_FuncExtCS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_FuncExtCS

# Register Extrema_FuncExtCS in _Extrema:
_Extrema.Extrema_FuncExtCS_swigregister(Extrema_FuncExtCS)

class Extrema_FuncExtSS(OCC.Core.math.math_FunctionSetWithDerivatives):
    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"""
        :rtype: None:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:rtype: None
        """
        _Extrema.Extrema_FuncExtSS_swiginit(self, _Extrema.new_Extrema_FuncExtSS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_FuncExtSS_Initialize)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_FuncExtSS_NbExt)
    PointOnS1 = _swig_new_instance_method(_Extrema.Extrema_FuncExtSS_PointOnS1)
    PointOnS2 = _swig_new_instance_method(_Extrema.Extrema_FuncExtSS_PointOnS2)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_FuncExtSS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_FuncExtSS

# Register Extrema_FuncExtSS in _Extrema:
_Extrema.Extrema_FuncExtSS_swigregister(Extrema_FuncExtSS)

class Extrema_FuncPSDist(OCC.Core.math.math_MultipleVarFunctionWithGradient):
    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"""
        * Constructor.
        	:param theS:
        	:type theS: Adaptor3d_Surface
        	:param theP:
        	:type theP: gp_Pnt
        	:rtype: None
        """
        _Extrema.Extrema_FuncPSDist_swiginit(self, _Extrema.new_Extrema_FuncPSDist(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_FuncPSDist

# Register Extrema_FuncPSDist in _Extrema:
_Extrema.Extrema_FuncPSDist_swigregister(Extrema_FuncPSDist)

class Extrema_FuncPSNorm(OCC.Core.math.math_FunctionSetWithDerivatives):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: Adaptor3d_Surface
        	:rtype: None
        """
        _Extrema.Extrema_FuncPSNorm_swiginit(self, _Extrema.new_Extrema_FuncPSNorm(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_FuncPSNorm_Initialize)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_FuncPSNorm_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_FuncPSNorm_Point)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_FuncPSNorm_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_FuncPSNorm_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_FuncPSNorm

# Register Extrema_FuncPSNorm in _Extrema:
_Extrema.Extrema_FuncPSNorm_swigregister(Extrema_FuncPSNorm)

class Extrema_GenExtCS(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"""
        :rtype: None* It calculates all the distances. The function F(u,v)=distance(S1(u1,v1),S2(u2,v2)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surfaces. NbU and NbV are used to locate the close points on the surface and NbT on the curve to find the zeros.
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param NbT:
        	:type NbT: int
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None* It calculates all the distances. The function F(u,v)=distance(P,S(u,v)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surface. NbT,NbU and NbV are used to locate the close points to find the zeros.
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param NbT:
        	:type NbT: int
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param tmin:
        	:type tmin: float
        	:param tsup:
        	:type tsup: float
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param Vmin:
        	:type Vmin: float
        	:param Vsup:
        	:type Vsup: float
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None
        """
        _Extrema.Extrema_GenExtCS_swiginit(self, _Extrema.new_Extrema_GenExtCS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_Perform)
    PointOnCurve = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_PointOnCurve)
    PointOnSurface = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_PointOnSurface)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenExtCS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenExtCS

# Register Extrema_GenExtCS in _Extrema:
_Extrema.Extrema_GenExtCS_swigregister(Extrema_GenExtCS)

class Extrema_GenExtPS(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"""
        :rtype: None* It calculates all the distances. The function F(u,v)=distance(P,S(u,v)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surface. NbU and NbV are used to locate the close points to find the zeros. They must be great enough such that if there is N extrema, there will be N extrema between P and the grid. TolU et TolV are used to determine the conditions to stop the iterations; at the iteration number n: (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:param F: default value is Extrema_ExtFlag_MINMAX
        	:type F: Extrema_ExtFlag
        	:param A: default value is Extrema_ExtAlgo_Grad
        	:type A: Extrema_ExtAlgo
        	:rtype: None* It calculates all the distances. The function F(u,v)=distance(P,S(u,v)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surface. NbU and NbV are used to locate the close points to find the zeros. They must be great enough such that if there is N extrema, there will be N extrema between P and the grid. TolU et TolV are used to determine the conditions to stop the iterations; at the iteration number n: (Un - Un-1) < TolU and (Vn - Vn-1) < TolV .
        	:param P:
        	:type P: gp_Pnt
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param Vmin:
        	:type Vmin: float
        	:param Vsup:
        	:type Vsup: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:param F: default value is Extrema_ExtFlag_MINMAX
        	:type F: Extrema_ExtFlag
        	:param A: default value is Extrema_ExtAlgo_Grad
        	:type A: Extrema_ExtAlgo
        	:rtype: None
        """
        _Extrema.Extrema_GenExtPS_swiginit(self, _Extrema.new_Extrema_GenExtPS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_Point)
    SetAlgo = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_SetAlgo)
    SetFlag = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_SetFlag)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenExtPS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenExtPS

# Register Extrema_GenExtPS in _Extrema:
_Extrema.Extrema_GenExtPS_swigregister(Extrema_GenExtPS)

class Extrema_GenExtSS(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"""
        :rtype: None* It calculates all the distances. The function F(u,v)=distance(S1(u1,v1),S2(u2,v2)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surfaces. NbU and NbV are used to locate the close points to find the zeros.
        	:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None* It calculates all the distances. The function F(u,v)=distance(P,S(u,v)) has an extremum when gradient(F)=0. The algorithm searchs all the zeros inside the definition ranges of the surface. NbU and NbV are used to locate the close points to find the zeros.
        	:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:param NbU:
        	:type NbU: int
        	:param NbV:
        	:type NbV: int
        	:param U1min:
        	:type U1min: float
        	:param U1sup:
        	:type U1sup: float
        	:param V1min:
        	:type V1min: float
        	:param V1sup:
        	:type V1sup: float
        	:param U2min:
        	:type U2min: float
        	:param U2sup:
        	:type U2sup: float
        	:param V2min:
        	:type V2min: float
        	:param V2sup:
        	:type V2sup: float
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None
        """
        _Extrema.Extrema_GenExtSS_swiginit(self, _Extrema.new_Extrema_GenExtSS(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_IsDone)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_NbExt)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_Perform)
    PointOnS1 = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_PointOnS1)
    PointOnS2 = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_PointOnS2)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenExtSS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenExtSS

# Register Extrema_GenExtSS in _Extrema:
_Extrema.Extrema_GenExtSS_swigregister(Extrema_GenExtSS)

class Extrema_GenLocateExtCS(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"""
        :rtype: None* Calculates the distance with two close points. The close points are defined by the parameter values T for C and (U,V) for S. The function F(t,u,v)=distance(C(t),S(u,v)) has an extremun when gradient(F)=0. The algorithm searchs a zero near the close points.
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param S:
        	:type S: Adaptor3d_Surface
        	:param T:
        	:type T: float
        	:param U:
        	:type U: float
        	:param V:
        	:type V: float
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None
        """
        _Extrema.Extrema_GenLocateExtCS_swiginit(self, _Extrema.new_Extrema_GenLocateExtCS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtCS_IsDone)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtCS_Perform)
    PointOnCurve = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtCS_PointOnCurve)
    PointOnSurface = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtCS_PointOnSurface)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtCS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenLocateExtCS

# Register Extrema_GenLocateExtCS in _Extrema:
_Extrema.Extrema_GenLocateExtCS_swigregister(Extrema_GenLocateExtCS)

class Extrema_GenLocateExtPS(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"""
        * Constructor.
        	:param theS:
        	:type theS: Adaptor3d_Surface
        	:param theTolU: default value is Precision::Confusion()
        	:type theTolU: float
        	:param theTolV: default value is Precision::Confusion()
        	:type theTolV: float
        	:rtype: None
        """
        _Extrema.Extrema_GenLocateExtPS_swiginit(self, _Extrema.new_Extrema_GenLocateExtPS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtPS_IsDone)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtPS_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtPS_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtPS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenLocateExtPS

# Register Extrema_GenLocateExtPS in _Extrema:
_Extrema.Extrema_GenLocateExtPS_swigregister(Extrema_GenLocateExtPS)

class Extrema_GenLocateExtSS(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"""
        :rtype: None* Calculates the distance with two close points. The close points are defined by the parameter values (U1,V1) for S1 and (U2,V2) for S2. The function F(u1,v1,u2,v2)=distance(S1(u1,v1),S2(u2,v2)) has an extremun when gradient(F)=0. The algorithm searchs a zero near the close points.
        	:param S1:
        	:type S1: Adaptor3d_Surface
        	:param S2:
        	:type S2: Adaptor3d_Surface
        	:param U1:
        	:type U1: float
        	:param V1:
        	:type V1: float
        	:param U2:
        	:type U2: float
        	:param V2:
        	:type V2: float
        	:param Tol1:
        	:type Tol1: float
        	:param Tol2:
        	:type Tol2: float
        	:rtype: None
        """
        _Extrema.Extrema_GenLocateExtSS_swiginit(self, _Extrema.new_Extrema_GenLocateExtSS(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtSS_IsDone)
    Perform = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtSS_Perform)
    PointOnS1 = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtSS_PointOnS1)
    PointOnS2 = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtSS_PointOnS2)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_GenLocateExtSS_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GenLocateExtSS

# Register Extrema_GenLocateExtSS in _Extrema:
_Extrema.Extrema_GenLocateExtSS_swigregister(Extrema_GenLocateExtSS)

class Extrema_GlobOptFuncCCC0(OCC.Core.math.math_MultipleVarFunction):
    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"""
        :param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:rtype: None:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_GlobOptFuncCCC0_swiginit(self, _Extrema.new_Extrema_GlobOptFuncCCC0(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GlobOptFuncCCC0

# Register Extrema_GlobOptFuncCCC0 in _Extrema:
_Extrema.Extrema_GlobOptFuncCCC0_swigregister(Extrema_GlobOptFuncCCC0)

class Extrema_GlobOptFuncCCC1(OCC.Core.math.math_MultipleVarFunctionWithGradient):
    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"""
        :param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:rtype: None:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_GlobOptFuncCCC1_swiginit(self, _Extrema.new_Extrema_GlobOptFuncCCC1(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GlobOptFuncCCC1

# Register Extrema_GlobOptFuncCCC1 in _Extrema:
_Extrema.Extrema_GlobOptFuncCCC1_swigregister(Extrema_GlobOptFuncCCC1)

class Extrema_GlobOptFuncCCC2(OCC.Core.math.math_MultipleVarFunctionWithHessian):
    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"""
        :param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:rtype: None:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_GlobOptFuncCCC2_swiginit(self, _Extrema.new_Extrema_GlobOptFuncCCC2(*args))
    Values = _swig_new_instance_method(_Extrema.Extrema_GlobOptFuncCCC2_Values)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GlobOptFuncCCC2

# Register Extrema_GlobOptFuncCCC2 in _Extrema:
_Extrema.Extrema_GlobOptFuncCCC2_swigregister(Extrema_GlobOptFuncCCC2)

class Extrema_GlobOptFuncCS(OCC.Core.math.math_MultipleVarFunctionWithHessian):
    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"""
        * Curve and surface should exist during all the lifetime of Extrema_GlobOptFuncCS.
        	:param C:
        	:type C: Adaptor3d_Curve *
        	:param S:
        	:type S: Adaptor3d_Surface *
        	:rtype: None
        """
        _Extrema.Extrema_GlobOptFuncCS_swiginit(self, _Extrema.new_Extrema_GlobOptFuncCS(*args))
    Values = _swig_new_instance_method(_Extrema.Extrema_GlobOptFuncCS_Values)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_GlobOptFuncCS

# Register Extrema_GlobOptFuncCS in _Extrema:
_Extrema.Extrema_GlobOptFuncCS_swigregister(Extrema_GlobOptFuncCS)

class Extrema_LocECC(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"""
        * Calculates the distance with a close point. The close point is defined by a parameter value on each curve. The function F(u,v)=distance(C1(u),C2(v)) has an extremun when gradient(f)=0. The algorithm searchs the zero near the close point.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param V0:
        	:type V0: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None
        """
        _Extrema.Extrema_LocECC_swiginit(self, _Extrema.new_Extrema_LocECC(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocECC_IsDone)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocECC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocECC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocECC

# Register Extrema_LocECC in _Extrema:
_Extrema.Extrema_LocECC_swigregister(Extrema_LocECC)

class Extrema_LocECC2d(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"""
        * Calculates the distance with a close point. The close point is defined by a parameter value on each curve. The function F(u,v)=distance(C1(u),C2(v)) has an extremun when gradient(f)=0. The algorithm searchs the zero near the close point.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param V0:
        	:type V0: float
        	:param TolU:
        	:type TolU: float
        	:param TolV:
        	:type TolV: float
        	:rtype: None
        """
        _Extrema.Extrema_LocECC2d_swiginit(self, _Extrema.new_Extrema_LocECC2d(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocECC2d_IsDone)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocECC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocECC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocECC2d

# Register Extrema_LocECC2d in _Extrema:
_Extrema.Extrema_LocECC2d_swigregister(Extrema_LocECC2d)

class Extrema_LocEPCOfLocateExtPC(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"""
        :rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. TolU is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolU.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param TolU:
        	:type TolU: float
        	:rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. Zeros are searched between Umin et Usup. TolU is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolU.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:rtype: None
        """
        _Extrema.Extrema_LocEPCOfLocateExtPC_swiginit(self, _Extrema.new_Extrema_LocEPCOfLocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_IsMin)
    Perform = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocEPCOfLocateExtPC

# Register Extrema_LocEPCOfLocateExtPC in _Extrema:
_Extrema.Extrema_LocEPCOfLocateExtPC_swigregister(Extrema_LocEPCOfLocateExtPC)

class Extrema_LocEPCOfLocateExtPC2d(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"""
        :rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. TolU is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolU.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param TolU:
        	:type TolU: float
        	:rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. Zeros are searched between Umin et Usup. TolU is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolU.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolU:
        	:type TolU: float
        	:rtype: None
        """
        _Extrema.Extrema_LocEPCOfLocateExtPC2d_swiginit(self, _Extrema.new_Extrema_LocEPCOfLocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_IsMin)
    Perform = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocEPCOfLocateExtPC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocEPCOfLocateExtPC2d

# Register Extrema_LocEPCOfLocateExtPC2d in _Extrema:
_Extrema.Extrema_LocEPCOfLocateExtPC2d_swigregister(Extrema_LocEPCOfLocateExtPC2d)

class Extrema_LocateExtCC(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"""
        * Calculates the distance with a close point. The close point is defined by a parameter value on each curve. The function F(u,v)=distance(C1(u),C2(v)) has an extremun when gradient(f)=0. The algorithm searchs the zero near the close point.
        	:param C1:
        	:type C1: Adaptor3d_Curve
        	:param C2:
        	:type C2: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param V0:
        	:type V0: float
        	:rtype: None
        """
        _Extrema.Extrema_LocateExtCC_swiginit(self, _Extrema.new_Extrema_LocateExtCC(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC_IsDone)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocateExtCC

# Register Extrema_LocateExtCC in _Extrema:
_Extrema.Extrema_LocateExtCC_swigregister(Extrema_LocateExtCC)

class Extrema_LocateExtCC2d(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"""
        * Calculates the distance with a close point. The close point is defined by a parameter value on each curve. The function F(u,v)=distance(C1(u),C2(v)) has an extremun when gradient(f)=0. The algorithm searchs the zero near the close point.
        	:param C1:
        	:type C1: Adaptor2d_Curve2d
        	:param C2:
        	:type C2: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param V0:
        	:type V0: float
        	:rtype: None
        """
        _Extrema.Extrema_LocateExtCC2d_swiginit(self, _Extrema.new_Extrema_LocateExtCC2d(*args))
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC2d_IsDone)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocateExtCC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocateExtCC2d

# Register Extrema_LocateExtCC2d in _Extrema:
_Extrema.Extrema_LocateExtCC2d_swigregister(Extrema_LocateExtCC2d)

class Extrema_LocateExtPC(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"""
        :rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. TolF is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolF.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. Zeros are searched between Umin et Usup. TolF is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolF.
        	:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:param U0:
        	:type U0: float
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_LocateExtPC_swiginit(self, _Extrema.new_Extrema_LocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_IsMin)
    Perform = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocateExtPC

# Register Extrema_LocateExtPC in _Extrema:
_Extrema.Extrema_LocateExtPC_swigregister(Extrema_LocateExtPC)

class Extrema_LocateExtPC2d(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"""
        :rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. TolF is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolF.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None* Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searchs a zero near the close point. Zeros are searched between Umin et Usup. TolF is used to decide to stop the iterations. At the nth iteration, the criteria is: abs(Un - Un-1) < TolF.
        	:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:param U0:
        	:type U0: float
        	:param Umin:
        	:type Umin: float
        	:param Usup:
        	:type Usup: float
        	:param TolF:
        	:type TolF: float
        	:rtype: None
        """
        _Extrema.Extrema_LocateExtPC2d_swiginit(self, _Extrema.new_Extrema_LocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_Initialize)
    IsDone = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_IsDone)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_IsMin)
    Perform = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_Perform)
    Point = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_Point)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_LocateExtPC2d_SquareDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_LocateExtPC2d

# Register Extrema_LocateExtPC2d in _Extrema:
_Extrema.Extrema_LocateExtPC2d_swigregister(Extrema_LocateExtPC2d)

class Extrema_PCFOfEPCOfELPCOfLocateExtPC(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:rtype: None
        """
        _Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_swiginit(self, _Extrema.new_Extrema_PCFOfEPCOfELPCOfLocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCFOfEPCOfELPCOfLocateExtPC

# Register Extrema_PCFOfEPCOfELPCOfLocateExtPC in _Extrema:
_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC_swigregister(Extrema_PCFOfEPCOfELPCOfLocateExtPC)

class Extrema_PCFOfEPCOfELPCOfLocateExtPC2d(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_swiginit(self, _Extrema.new_Extrema_PCFOfEPCOfELPCOfLocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCFOfEPCOfELPCOfLocateExtPC2d

# Register Extrema_PCFOfEPCOfELPCOfLocateExtPC2d in _Extrema:
_Extrema.Extrema_PCFOfEPCOfELPCOfLocateExtPC2d_swigregister(Extrema_PCFOfEPCOfELPCOfLocateExtPC2d)

class Extrema_PCFOfEPCOfExtPC(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:rtype: None
        """
        _Extrema.Extrema_PCFOfEPCOfExtPC_swiginit(self, _Extrema.new_Extrema_PCFOfEPCOfExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCFOfEPCOfExtPC

# Register Extrema_PCFOfEPCOfExtPC in _Extrema:
_Extrema.Extrema_PCFOfEPCOfExtPC_swigregister(Extrema_PCFOfEPCOfExtPC)

class Extrema_PCFOfEPCOfExtPC2d(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_PCFOfEPCOfExtPC2d_swiginit(self, _Extrema.new_Extrema_PCFOfEPCOfExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCFOfEPCOfExtPC2d_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCFOfEPCOfExtPC2d

# Register Extrema_PCFOfEPCOfExtPC2d in _Extrema:
_Extrema.Extrema_PCFOfEPCOfExtPC2d_swigregister(Extrema_PCFOfEPCOfExtPC2d)

class Extrema_PCLocFOfLocEPCOfLocateExtPC(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt
        	:param C:
        	:type C: Adaptor3d_Curve
        	:rtype: None
        """
        _Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_swiginit(self, _Extrema.new_Extrema_PCLocFOfLocEPCOfLocateExtPC(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCLocFOfLocEPCOfLocateExtPC

# Register Extrema_PCLocFOfLocEPCOfLocateExtPC in _Extrema:
_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC_swigregister(Extrema_PCLocFOfLocEPCOfLocateExtPC)

class Extrema_PCLocFOfLocEPCOfLocateExtPC2d(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :rtype: None:param P:
        	:type P: gp_Pnt2d
        	:param C:
        	:type C: Adaptor2d_Curve2d
        	:rtype: None
        """
        _Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_swiginit(self, _Extrema.new_Extrema_PCLocFOfLocEPCOfLocateExtPC2d(*args))
    Initialize = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_Initialize)
    IsMin = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_IsMin)
    NbExt = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_NbExt)
    Point = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_Point)
    SearchOfTolerance = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_SearchOfTolerance)
    SetPoint = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_SetPoint)
    SquareDistance = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_SquareDistance)
    SubIntervalInitialize = _swig_new_instance_method(_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_SubIntervalInitialize)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_PCLocFOfLocEPCOfLocateExtPC2d

# Register Extrema_PCLocFOfLocEPCOfLocateExtPC2d in _Extrema:
_Extrema.Extrema_PCLocFOfLocEPCOfLocateExtPC2d_swigregister(Extrema_PCLocFOfLocEPCOfLocateExtPC2d)

class Extrema_POnCurv(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"""
        * Creation of an indefinite point on curve.
        	:rtype: None* Creation of a point on curve with a parameter value on the curve and a Pnt from gp.
        	:param U:
        	:type U: float
        	:param P:
        	:type P: gp_Pnt
        	:rtype: None
        """
        _Extrema.Extrema_POnCurv_swiginit(self, _Extrema.new_Extrema_POnCurv(*args))
    Parameter = _swig_new_instance_method(_Extrema.Extrema_POnCurv_Parameter)
    SetValues = _swig_new_instance_method(_Extrema.Extrema_POnCurv_SetValues)
    Value = _swig_new_instance_method(_Extrema.Extrema_POnCurv_Value)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_POnCurv

# Register Extrema_POnCurv in _Extrema:
_Extrema.Extrema_POnCurv_swigregister(Extrema_POnCurv)

class Extrema_POnCurv2d(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"""
        * Creation of an indefinite point on curve.
        	:rtype: None* Creation of a point on curve with a parameter value on the curve and a Pnt from gp.
        	:param U:
        	:type U: float
        	:param P:
        	:type P: gp_Pnt2d
        	:rtype: None
        """
        _Extrema.Extrema_POnCurv2d_swiginit(self, _Extrema.new_Extrema_POnCurv2d(*args))
    Parameter = _swig_new_instance_method(_Extrema.Extrema_POnCurv2d_Parameter)
    SetValues = _swig_new_instance_method(_Extrema.Extrema_POnCurv2d_SetValues)
    Value = _swig_new_instance_method(_Extrema.Extrema_POnCurv2d_Value)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_POnCurv2d

# Register Extrema_POnCurv2d in _Extrema:
_Extrema.Extrema_POnCurv2d_swigregister(Extrema_POnCurv2d)

class Extrema_POnSurf(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"""
        * Creation of an indefinite point on surface.
        	:rtype: None* Creation of a point on surface with parameter values on the surface and a Pnt from gp.
        	:param U:
        	:type U: float
        	:param V:
        	:type V: float
        	:param P:
        	:type P: gp_Pnt
        	:rtype: None
        """
        _Extrema.Extrema_POnSurf_swiginit(self, _Extrema.new_Extrema_POnSurf(*args))
    Parameter = _swig_new_instance_method(_Extrema.Extrema_POnSurf_Parameter)
    SetParameters = _swig_new_instance_method(_Extrema.Extrema_POnSurf_SetParameters)
    Value = _swig_new_instance_method(_Extrema.Extrema_POnSurf_Value)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_POnSurf

# Register Extrema_POnSurf in _Extrema:
_Extrema.Extrema_POnSurf_swigregister(Extrema_POnSurf)

class Extrema_POnSurfParams(Extrema_POnSurf):
    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"""
        * empty constructor
        	:rtype: None* Creation of a point on surface with parameter values on the surface and a Pnt from gp.
        	:param theU:
        	:type theU: float
        	:param theV:
        	:type theV: float
        	:param thePnt:
        	:type thePnt: gp_Pnt
        	:rtype: None
        """
        _Extrema.Extrema_POnSurfParams_swiginit(self, _Extrema.new_Extrema_POnSurfParams(*args))
    GetElementType = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_GetElementType)
    GetIndices = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_GetIndices)
    GetSqrDistance = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_GetSqrDistance)
    SetElementType = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_SetElementType)
    SetIndices = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_SetIndices)
    SetSqrDistance = _swig_new_instance_method(_Extrema.Extrema_POnSurfParams_SetSqrDistance)

    __repr__ = _dumps_object

    __swig_destroy__ = _Extrema.delete_Extrema_POnSurfParams

# Register Extrema_POnSurfParams in _Extrema:
_Extrema.Extrema_POnSurfParams_swigregister(Extrema_POnSurfParams)

class Extrema_HArray1OfPOnSurf(Extrema_Array1OfPOnSurf, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray1OfPOnSurf_swiginit(self, _Extrema.new_Extrema_HArray1OfPOnSurf(*args))
    Array1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnSurf_Array1)
    ChangeArray1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnSurf_ChangeArray1)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray1OfPOnSurf

# Register Extrema_HArray1OfPOnSurf in _Extrema:
_Extrema.Extrema_HArray1OfPOnSurf_swigregister(Extrema_HArray1OfPOnSurf)

class Extrema_HArray1OfPOnCurv(Extrema_Array1OfPOnCurv, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray1OfPOnCurv_swiginit(self, _Extrema.new_Extrema_HArray1OfPOnCurv(*args))
    Array1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnCurv_Array1)
    ChangeArray1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnCurv_ChangeArray1)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray1OfPOnCurv

# Register Extrema_HArray1OfPOnCurv in _Extrema:
_Extrema.Extrema_HArray1OfPOnCurv_swigregister(Extrema_HArray1OfPOnCurv)

class Extrema_HArray1OfPOnCurv2d(Extrema_Array1OfPOnCurv2d, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray1OfPOnCurv2d_swiginit(self, _Extrema.new_Extrema_HArray1OfPOnCurv2d(*args))
    Array1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnCurv2d_Array1)
    ChangeArray1 = _swig_new_instance_method(_Extrema.Extrema_HArray1OfPOnCurv2d_ChangeArray1)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray1OfPOnCurv2d

# Register Extrema_HArray1OfPOnCurv2d in _Extrema:
_Extrema.Extrema_HArray1OfPOnCurv2d_swigregister(Extrema_HArray1OfPOnCurv2d)

class Extrema_HArray2OfPOnCurv2d(Extrema_Array2OfPOnCurv2d, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray2OfPOnCurv2d_swiginit(self, _Extrema.new_Extrema_HArray2OfPOnCurv2d(*args))
    Array2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnCurv2d_Array2)
    ChangeArray2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnCurv2d_ChangeArray2)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray2OfPOnCurv2d

# Register Extrema_HArray2OfPOnCurv2d in _Extrema:
_Extrema.Extrema_HArray2OfPOnCurv2d_swigregister(Extrema_HArray2OfPOnCurv2d)

class Extrema_HArray2OfPOnCurv(Extrema_Array2OfPOnCurv, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray2OfPOnCurv_swiginit(self, _Extrema.new_Extrema_HArray2OfPOnCurv(*args))
    Array2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnCurv_Array2)
    ChangeArray2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnCurv_ChangeArray2)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray2OfPOnCurv

# Register Extrema_HArray2OfPOnCurv in _Extrema:
_Extrema.Extrema_HArray2OfPOnCurv_swigregister(Extrema_HArray2OfPOnCurv)

class Extrema_HArray2OfPOnSurf(Extrema_Array2OfPOnSurf, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray2OfPOnSurf_swiginit(self, _Extrema.new_Extrema_HArray2OfPOnSurf(*args))
    Array2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnSurf_Array2)
    ChangeArray2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnSurf_ChangeArray2)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray2OfPOnSurf

# Register Extrema_HArray2OfPOnSurf in _Extrema:
_Extrema.Extrema_HArray2OfPOnSurf_swigregister(Extrema_HArray2OfPOnSurf)

class Extrema_HArray2OfPOnSurfParams(Extrema_Array2OfPOnSurfParams, OCC.Core.Standard.Standard_Transient):
    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):
        _Extrema.Extrema_HArray2OfPOnSurfParams_swiginit(self, _Extrema.new_Extrema_HArray2OfPOnSurfParams(*args))
    Array2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnSurfParams_Array2)
    ChangeArray2 = _swig_new_instance_method(_Extrema.Extrema_HArray2OfPOnSurfParams_ChangeArray2)


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

    __swig_destroy__ = _Extrema.delete_Extrema_HArray2OfPOnSurfParams

# Register Extrema_HArray2OfPOnSurfParams in _Extrema:
_Extrema.Extrema_HArray2OfPOnSurfParams_swigregister(Extrema_HArray2OfPOnSurfParams)



