conopt.py

Go to the documentation of this file.

 
# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.5.0
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.
 
import typing
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import libconoptpy4
else:
    import libconoptpy4
 
import builtins as __builtin__
 
def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
 
 
def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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
 
 
class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
 
 
import weakref
 
class SwigPyIterator(object):
    r"""Proxy of C++ swig::SwigPyIterator class."""
 
    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__ = libconoptpy4.delete_SwigPyIterator
 
    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return libconoptpy4.SwigPyIterator_value(self)
 
    def incr(self, n=1):
        r"""
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
 
        Parameters
        ----------
        n: size_t
 
        """
        return libconoptpy4.SwigPyIterator_incr(self, n)
 
    def decr(self, n=1):
        r"""
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
 
        Parameters
        ----------
        n: size_t
 
        """
        return libconoptpy4.SwigPyIterator_decr(self, n)
 
    def distance(self, x):
        r"""
        distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
 
        Parameters
        ----------
        x: swig::SwigPyIterator const &
 
        """
        return libconoptpy4.SwigPyIterator_distance(self, x)
 
    def equal(self, x):
        r"""
        equal(SwigPyIterator self, SwigPyIterator x) -> bool
 
        Parameters
        ----------
        x: swig::SwigPyIterator const &
 
        """
        return libconoptpy4.SwigPyIterator_equal(self, x)
 
    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return libconoptpy4.SwigPyIterator_copy(self)
 
    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return libconoptpy4.SwigPyIterator___next__(self)
 
    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return libconoptpy4.SwigPyIterator_previous(self)
 
    def advance(self, n):
        r"""
        advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
 
        Parameters
        ----------
        n: ptrdiff_t
 
        """
        return libconoptpy4.SwigPyIterator_advance(self, n)
 
    def __eq__(self, x):
        r"""
        __eq__(SwigPyIterator self, SwigPyIterator x) -> bool
 
        Parameters
        ----------
        x: swig::SwigPyIterator const &
 
        """
        return libconoptpy4.SwigPyIterator___eq__(self, x)
 
    def __ne__(self, x):
        r"""
        __ne__(SwigPyIterator self, SwigPyIterator x) -> bool
 
        Parameters
        ----------
        x: swig::SwigPyIterator const &
 
        """
        return libconoptpy4.SwigPyIterator___ne__(self, x)
 
    def __iadd__(self, n):
        r"""
        __iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
 
        Parameters
        ----------
        n: ptrdiff_t
 
        """
        return libconoptpy4.SwigPyIterator___iadd__(self, n)
 
    def __isub__(self, n):
        r"""
        __isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
 
        Parameters
        ----------
        n: ptrdiff_t
 
        """
        return libconoptpy4.SwigPyIterator___isub__(self, n)
 
    def __add__(self, n):
        r"""
        __add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
 
        Parameters
        ----------
        n: ptrdiff_t
 
        """
        return libconoptpy4.SwigPyIterator___add__(self, n)
 
    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
 
        Parameters
        ----------
        n: ptrdiff_t
 
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
 
        Parameters
        ----------
        x: swig::SwigPyIterator const &
 
        """
        return libconoptpy4.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
 
# Register SwigPyIterator in libconoptpy4:
libconoptpy4.SwigPyIterator_swigregister(SwigPyIterator)
class IntVector(object):
    r"""Proxy of C++ std::vector< int > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def iterator(self):
        r"""iterator(IntVector self) -> SwigPyIterator"""
        return libconoptpy4.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __bool__(self):
        r"""__bool__(IntVector self) -> bool"""
        return libconoptpy4.IntVector___bool__(self)
 
    def __len__(self):
        r"""__len__(IntVector self) -> std::vector< int >::size_type"""
        return libconoptpy4.IntVector___len__(self)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(IntVector self, std::vector< int >::difference_type i)
 
        Parameters
        ----------
        i: std::vector< int >::difference_type
 
        __delitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        """
        return libconoptpy4.IntVector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(IntVector self, SWIGPY_SLICEOBJECT * slice) -> IntVector
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
 
        Parameters
        ----------
        i: std::vector< int >::difference_type
 
        """
        return libconoptpy4.IntVector___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice, IntVector v)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< int,std::allocator< int > > const &
 
        __setitem__(IntVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        i: std::vector< int >::difference_type
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector___setitem__(self, *args)
 
    def pop(self):
        r"""pop(IntVector self) -> std::vector< int >::value_type"""
        return libconoptpy4.IntVector_pop(self)
 
    def append(self, x):
        r"""
        append(IntVector self, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector_append(self, x)
 
    def empty(self):
        r"""empty(IntVector self) -> bool"""
        return libconoptpy4.IntVector_empty(self)
 
    def size(self):
        r"""size(IntVector self) -> std::vector< int >::size_type"""
        return libconoptpy4.IntVector_size(self)
 
    def swap(self, v):
        r"""
        swap(IntVector self, IntVector v)
 
        Parameters
        ----------
        v: std::vector< int > &
 
        """
        return libconoptpy4.IntVector_swap(self, v)
 
    def begin(self):
        r"""begin(IntVector self) -> std::vector< int >::iterator"""
        return libconoptpy4.IntVector_begin(self)
 
    def end(self):
        r"""end(IntVector self) -> std::vector< int >::iterator"""
        return libconoptpy4.IntVector_end(self)
 
    def rbegin(self):
        r"""rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return libconoptpy4.IntVector_rbegin(self)
 
    def rend(self):
        r"""rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return libconoptpy4.IntVector_rend(self)
 
    def clear(self):
        r"""clear(IntVector self)"""
        return libconoptpy4.IntVector_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return libconoptpy4.IntVector_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(IntVector self)"""
        return libconoptpy4.IntVector_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
 
        Parameters
        ----------
        pos: std::vector< int >::iterator
 
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
 
        Parameters
        ----------
        first: std::vector< int >::iterator
        last: std::vector< int >::iterator
 
        """
        return libconoptpy4.IntVector_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(IntVector self) -> IntVector
        __init__(IntVector self, IntVector other) -> IntVector
 
        Parameters
        ----------
        other: std::vector< int > const &
 
        __init__(IntVector self, std::vector< int >::size_type size) -> IntVector
 
        Parameters
        ----------
        size: std::vector< int >::size_type
 
        __init__(IntVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
 
        Parameters
        ----------
        size: std::vector< int >::size_type
        value: std::vector< int >::value_type const &
 
        """
        libconoptpy4.IntVector_swiginit(self, libconoptpy4.new_IntVector(*args))
 
    def push_back(self, x):
        r"""
        push_back(IntVector self, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector_push_back(self, x)
 
    def front(self):
        r"""front(IntVector self) -> std::vector< int >::value_type const &"""
        return libconoptpy4.IntVector_front(self)
 
    def back(self):
        r"""back(IntVector self) -> std::vector< int >::value_type const &"""
        return libconoptpy4.IntVector_back(self)
 
    def assign(self, n, x):
        r"""
        assign(IntVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(IntVector self, std::vector< int >::size_type new_size)
 
        Parameters
        ----------
        new_size: std::vector< int >::size_type
 
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        new_size: std::vector< int >::size_type
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::value_type const & x) -> std::vector< int >::iterator
 
        Parameters
        ----------
        pos: std::vector< int >::iterator
        x: std::vector< int >::value_type const &
 
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
 
        Parameters
        ----------
        pos: std::vector< int >::iterator
        n: std::vector< int >::size_type
        x: std::vector< int >::value_type const &
 
        """
        return libconoptpy4.IntVector_insert(self, *args)
 
    def reserve(self, n):
        r"""
        reserve(IntVector self, std::vector< int >::size_type n)
 
        Parameters
        ----------
        n: std::vector< int >::size_type
 
        """
        return libconoptpy4.IntVector_reserve(self, n)
 
    def capacity(self):
        r"""capacity(IntVector self) -> std::vector< int >::size_type"""
        return libconoptpy4.IntVector_capacity(self)
    __swig_destroy__ = libconoptpy4.delete_IntVector
 
# Register IntVector in libconoptpy4:
libconoptpy4.IntVector_swigregister(IntVector)
class DoubleVector(object):
    r"""Proxy of C++ std::vector< double > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def iterator(self):
        r"""iterator(DoubleVector self) -> SwigPyIterator"""
        return libconoptpy4.DoubleVector_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __bool__(self):
        r"""__bool__(DoubleVector self) -> bool"""
        return libconoptpy4.DoubleVector___bool__(self)
 
    def __len__(self):
        r"""__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return libconoptpy4.DoubleVector___len__(self)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(DoubleVector self, std::vector< double >::difference_type i)
 
        Parameters
        ----------
        i: std::vector< double >::difference_type
 
        __delitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        """
        return libconoptpy4.DoubleVector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice) -> DoubleVector
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
 
        Parameters
        ----------
        i: std::vector< double >::difference_type
 
        """
        return libconoptpy4.DoubleVector___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice, DoubleVector v)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< double,std::allocator< double > > const &
 
        __setitem__(DoubleVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        i: std::vector< double >::difference_type
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector___setitem__(self, *args)
 
    def pop(self):
        r"""pop(DoubleVector self) -> std::vector< double >::value_type"""
        return libconoptpy4.DoubleVector_pop(self)
 
    def append(self, x):
        r"""
        append(DoubleVector self, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector_append(self, x)
 
    def empty(self):
        r"""empty(DoubleVector self) -> bool"""
        return libconoptpy4.DoubleVector_empty(self)
 
    def size(self):
        r"""size(DoubleVector self) -> std::vector< double >::size_type"""
        return libconoptpy4.DoubleVector_size(self)
 
    def swap(self, v):
        r"""
        swap(DoubleVector self, DoubleVector v)
 
        Parameters
        ----------
        v: std::vector< double > &
 
        """
        return libconoptpy4.DoubleVector_swap(self, v)
 
    def begin(self):
        r"""begin(DoubleVector self) -> std::vector< double >::iterator"""
        return libconoptpy4.DoubleVector_begin(self)
 
    def end(self):
        r"""end(DoubleVector self) -> std::vector< double >::iterator"""
        return libconoptpy4.DoubleVector_end(self)
 
    def rbegin(self):
        r"""rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return libconoptpy4.DoubleVector_rbegin(self)
 
    def rend(self):
        r"""rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return libconoptpy4.DoubleVector_rend(self)
 
    def clear(self):
        r"""clear(DoubleVector self)"""
        return libconoptpy4.DoubleVector_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return libconoptpy4.DoubleVector_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(DoubleVector self)"""
        return libconoptpy4.DoubleVector_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(DoubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
 
        Parameters
        ----------
        pos: std::vector< double >::iterator
 
        erase(DoubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
 
        Parameters
        ----------
        first: std::vector< double >::iterator
        last: std::vector< double >::iterator
 
        """
        return libconoptpy4.DoubleVector_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(DoubleVector self) -> DoubleVector
        __init__(DoubleVector self, DoubleVector other) -> DoubleVector
 
        Parameters
        ----------
        other: std::vector< double > const &
 
        __init__(DoubleVector self, std::vector< double >::size_type size) -> DoubleVector
 
        Parameters
        ----------
        size: std::vector< double >::size_type
 
        __init__(DoubleVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
 
        Parameters
        ----------
        size: std::vector< double >::size_type
        value: std::vector< double >::value_type const &
 
        """
        libconoptpy4.DoubleVector_swiginit(self, libconoptpy4.new_DoubleVector(*args))
 
    def push_back(self, x):
        r"""
        push_back(DoubleVector self, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector_push_back(self, x)
 
    def front(self):
        r"""front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return libconoptpy4.DoubleVector_front(self)
 
    def back(self):
        r"""back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return libconoptpy4.DoubleVector_back(self)
 
    def assign(self, n, x):
        r"""
        assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(DoubleVector self, std::vector< double >::size_type new_size)
 
        Parameters
        ----------
        new_size: std::vector< double >::size_type
 
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        new_size: std::vector< double >::size_type
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
 
        Parameters
        ----------
        pos: std::vector< double >::iterator
        x: std::vector< double >::value_type const &
 
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
 
        Parameters
        ----------
        pos: std::vector< double >::iterator
        n: std::vector< double >::size_type
        x: std::vector< double >::value_type const &
 
        """
        return libconoptpy4.DoubleVector_insert(self, *args)
 
    def reserve(self, n):
        r"""
        reserve(DoubleVector self, std::vector< double >::size_type n)
 
        Parameters
        ----------
        n: std::vector< double >::size_type
 
        """
        return libconoptpy4.DoubleVector_reserve(self, n)
 
    def capacity(self):
        r"""capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return libconoptpy4.DoubleVector_capacity(self)
    __swig_destroy__ = libconoptpy4.delete_DoubleVector
 
# Register DoubleVector in libconoptpy4:
libconoptpy4.DoubleVector_swigregister(DoubleVector)
class StringVector(object):
    r"""Proxy of C++ std::vector< std::string > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def iterator(self):
        r"""iterator(StringVector self) -> SwigPyIterator"""
        return libconoptpy4.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __bool__(self):
        r"""__bool__(StringVector self) -> bool"""
        return libconoptpy4.StringVector___bool__(self)
 
    def __len__(self):
        r"""__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return libconoptpy4.StringVector___len__(self)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(StringVector self, std::vector< std::string >::difference_type i)
 
        Parameters
        ----------
        i: std::vector< std::string >::difference_type
 
        __delitem__(StringVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        """
        return libconoptpy4.StringVector___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(StringVector self, SWIGPY_SLICEOBJECT * slice) -> StringVector
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
 
        Parameters
        ----------
        i: std::vector< std::string >::difference_type
 
        """
        return libconoptpy4.StringVector___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(StringVector self, SWIGPY_SLICEOBJECT * slice, StringVector v)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::vector< std::string,std::allocator< std::string > > const &
 
        __setitem__(StringVector self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        i: std::vector< std::string >::difference_type
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector___setitem__(self, *args)
 
    def pop(self):
        r"""pop(StringVector self) -> std::vector< std::string >::value_type"""
        return libconoptpy4.StringVector_pop(self)
 
    def append(self, x):
        r"""
        append(StringVector self, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector_append(self, x)
 
    def empty(self):
        r"""empty(StringVector self) -> bool"""
        return libconoptpy4.StringVector_empty(self)
 
    def size(self):
        r"""size(StringVector self) -> std::vector< std::string >::size_type"""
        return libconoptpy4.StringVector_size(self)
 
    def swap(self, v):
        r"""
        swap(StringVector self, StringVector v)
 
        Parameters
        ----------
        v: std::vector< std::string > &
 
        """
        return libconoptpy4.StringVector_swap(self, v)
 
    def begin(self):
        r"""begin(StringVector self) -> std::vector< std::string >::iterator"""
        return libconoptpy4.StringVector_begin(self)
 
    def end(self):
        r"""end(StringVector self) -> std::vector< std::string >::iterator"""
        return libconoptpy4.StringVector_end(self)
 
    def rbegin(self):
        r"""rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return libconoptpy4.StringVector_rbegin(self)
 
    def rend(self):
        r"""rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return libconoptpy4.StringVector_rend(self)
 
    def clear(self):
        r"""clear(StringVector self)"""
        return libconoptpy4.StringVector_clear(self)
 
    def get_allocator(self):
        r"""get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return libconoptpy4.StringVector_get_allocator(self)
 
    def pop_back(self):
        r"""pop_back(StringVector self)"""
        return libconoptpy4.StringVector_pop_back(self)
 
    def erase(self, *args):
        r"""
        erase(StringVector self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
 
        Parameters
        ----------
        pos: std::vector< std::string >::iterator
 
        erase(StringVector self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
 
        Parameters
        ----------
        first: std::vector< std::string >::iterator
        last: std::vector< std::string >::iterator
 
        """
        return libconoptpy4.StringVector_erase(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(StringVector self) -> StringVector
        __init__(StringVector self, StringVector other) -> StringVector
 
        Parameters
        ----------
        other: std::vector< std::string > const &
 
        __init__(StringVector self, std::vector< std::string >::size_type size) -> StringVector
 
        Parameters
        ----------
        size: std::vector< std::string >::size_type
 
        __init__(StringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
 
        Parameters
        ----------
        size: std::vector< std::string >::size_type
        value: std::vector< std::string >::value_type const &
 
        """
        libconoptpy4.StringVector_swiginit(self, libconoptpy4.new_StringVector(*args))
 
    def push_back(self, x):
        r"""
        push_back(StringVector self, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector_push_back(self, x)
 
    def front(self):
        r"""front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return libconoptpy4.StringVector_front(self)
 
    def back(self):
        r"""back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return libconoptpy4.StringVector_back(self)
 
    def assign(self, n, x):
        r"""
        assign(StringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector_assign(self, n, x)
 
    def resize(self, *args):
        r"""
        resize(StringVector self, std::vector< std::string >::size_type new_size)
 
        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
 
        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        new_size: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector_resize(self, *args)
 
    def insert(self, *args):
        r"""
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
 
        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        x: std::vector< std::string >::value_type const &
 
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
 
        Parameters
        ----------
        pos: std::vector< std::string >::iterator
        n: std::vector< std::string >::size_type
        x: std::vector< std::string >::value_type const &
 
        """
        return libconoptpy4.StringVector_insert(self, *args)
 
    def reserve(self, n):
        r"""
        reserve(StringVector self, std::vector< std::string >::size_type n)
 
        Parameters
        ----------
        n: std::vector< std::string >::size_type
 
        """
        return libconoptpy4.StringVector_reserve(self, n)
 
    def capacity(self):
        r"""capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return libconoptpy4.StringVector_capacity(self)
    __swig_destroy__ = libconoptpy4.delete_StringVector
 
# Register StringVector in libconoptpy4:
libconoptpy4.StringVector_swigregister(StringVector)
class IntArray3(object):
    r"""Proxy of C++ std::array< int,3 > class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def iterator(self):
        r"""iterator(IntArray3 self) -> SwigPyIterator"""
        return libconoptpy4.IntArray3_iterator(self)
    def __iter__(self):
        return self.iterator()
 
    def __bool__(self):
        r"""__bool__(IntArray3 self) -> bool"""
        return libconoptpy4.IntArray3___bool__(self)
 
    def __len__(self):
        r"""__len__(IntArray3 self) -> std::array< int,3 >::size_type"""
        return libconoptpy4.IntArray3___len__(self)
 
    def __delitem__(self, *args):
        r"""
        __delitem__(IntArray3 self, std::array< int,3 >::difference_type i)
 
        Parameters
        ----------
        i: std::array< int,3 >::difference_type
 
        __delitem__(IntArray3 self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        """
        return libconoptpy4.IntArray3___delitem__(self, *args)
 
    def __getitem__(self, *args):
        r"""
        __getitem__(IntArray3 self, SWIGPY_SLICEOBJECT * slice) -> IntArray3
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __getitem__(IntArray3 self, std::array< int,3 >::difference_type i) -> std::array< int,3 >::value_type const &
 
        Parameters
        ----------
        i: std::array< int,3 >::difference_type
 
        """
        return libconoptpy4.IntArray3___getitem__(self, *args)
 
    def __setitem__(self, *args):
        r"""
        __setitem__(IntArray3 self, SWIGPY_SLICEOBJECT * slice, IntArray3 v)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
        v: std::array< int,3 > const &
 
        __setitem__(IntArray3 self, SWIGPY_SLICEOBJECT * slice)
 
        Parameters
        ----------
        slice: SWIGPY_SLICEOBJECT *
 
        __setitem__(IntArray3 self, std::array< int,3 >::difference_type i, std::array< int,3 >::value_type const & x)
 
        Parameters
        ----------
        i: std::array< int,3 >::difference_type
        x: std::array< int,3 >::value_type const &
 
        """
        return libconoptpy4.IntArray3___setitem__(self, *args)
 
    def __init__(self, *args):
        r"""
        __init__(IntArray3 self) -> IntArray3
        __init__(IntArray3 self, IntArray3 other) -> IntArray3
 
        Parameters
        ----------
        other: std::array< int,3 > const &
 
        """
        libconoptpy4.IntArray3_swiginit(self, libconoptpy4.new_IntArray3(*args))
 
    def empty(self):
        r"""empty(IntArray3 self) -> bool"""
        return libconoptpy4.IntArray3_empty(self)
 
    def size(self):
        r"""size(IntArray3 self) -> std::array< int,3 >::size_type"""
        return libconoptpy4.IntArray3_size(self)
 
    def swap(self, v):
        r"""
        swap(IntArray3 self, IntArray3 v)
 
        Parameters
        ----------
        v: std::array< int,3 > &
 
        """
        return libconoptpy4.IntArray3_swap(self, v)
 
    def begin(self):
        r"""begin(IntArray3 self) -> std::array< int,3 >::iterator"""
        return libconoptpy4.IntArray3_begin(self)
 
    def end(self):
        r"""end(IntArray3 self) -> std::array< int,3 >::iterator"""
        return libconoptpy4.IntArray3_end(self)
 
    def rbegin(self):
        r"""rbegin(IntArray3 self) -> std::array< int,3 >::reverse_iterator"""
        return libconoptpy4.IntArray3_rbegin(self)
 
    def rend(self):
        r"""rend(IntArray3 self) -> std::array< int,3 >::reverse_iterator"""
        return libconoptpy4.IntArray3_rend(self)
 
    def front(self):
        r"""front(IntArray3 self) -> std::array< int,3 >::value_type const &"""
        return libconoptpy4.IntArray3_front(self)
 
    def back(self):
        r"""back(IntArray3 self) -> std::array< int,3 >::value_type const &"""
        return libconoptpy4.IntArray3_back(self)
 
    def fill(self, u):
        r"""
        fill(IntArray3 self, std::array< int,3 >::value_type const & u)
 
        Parameters
        ----------
        u: std::array< int,3 >::value_type const &
 
        """
        return libconoptpy4.IntArray3_fill(self, u)
    __swig_destroy__ = libconoptpy4.delete_IntArray3
 
# Register IntArray3 in libconoptpy4:
libconoptpy4.IntArray3_swigregister(IntArray3)
class Conopt(object):
    r"""
    The Conopt class
 
    @ingroup CONOPT_PYTHON
    """
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Infinity = libconoptpy4.Conopt_Infinity
    r"""CONOPT value for infinity"""
 
    def __init__(self, *args):
        r"""
        Constructor
 
        @param modelName: the name for the model.
 
        """
        libconoptpy4.Conopt_swiginit(self, libconoptpy4.new_Conopt(*args))
    __swig_destroy__ = libconoptpy4.delete_Conopt
 
    def solve(self):
        r"""
        @copydoc DEF_COI_SOLVE
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_solve(self)
 
    def checkModelAndParameters(self):
        r"""checks the model data and parameters to ensure it is setup correctly"""
        return libconoptpy4.Conopt_checkModelAndParameters(self)
 
    def controlVector(self):
        r"""
        returns the control vector pointer.
 
        This is for use in the C-interface methods
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_controlVector(self)
 
    def printStatus(self):
        r"""
        prints the status of the optimisation
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_printStatus(self)
 
    def getName(self):
        r"""
        returns the model name
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_getName(self)
 
    def loadModel(self, modeldata):
        r"""
        loads the model and stores the pointer in the interface
 
        The user creates an instantiation of the ConoptModelData that includes all details of the model, including
        function evaluation callbacks. This method loads the model data into Conopt before solving the problem.
 
        @param modeldata: a user defined ConoptModelData object
 
 
        @ingroup CONOPTPYTHON_MODELDATA
        """
        return libconoptpy4.Conopt_loadModel(self, modeldata)
 
    def modelStatus(self):
        r"""
        returns the model status
 
        """
        return libconoptpy4.Conopt_modelStatus(self)
 
    def solutionStatus(self):
        r"""
        return the solution status
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_solutionStatus(self)
 
    def iterations(self):
        r"""
        returns the number of iterations
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_iterations(self)
 
    def objectiveValue(self):
        r"""
        returns the objective value
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_objectiveValue(self)
 
    def getVariableValues(self):
        r"""
        returns the variable values
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getVariableValues(self)
 
    def getVariableMarginals(self):
        r"""
        returns the variable marginals
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getVariableMarginals(self)
 
    def getVariableBasisStatus(self):
        r"""
        returns the variable basis status
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getVariableBasisStatus(self)
 
    def getVariableStatus(self):
        r"""
        returns the variable status
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getVariableStatus(self)
 
    def getConstraintValues(self):
        r"""
        returns the constraint values
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getConstraintValues(self)
 
    def getConstraintMarginals(self):
        r"""
        returns the constraint marginals
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getConstraintMarginals(self)
 
    def getConstraintBasisStatus(self):
        r"""
        returns the constraint basis status
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getConstraintBasisStatus(self)
 
    def getConstraintStatus(self):
        r"""
        returns the constraint status
 
 
        @ingroup SOLUTION_STATUS_METHODS_PYTHON
        """
        return libconoptpy4.Conopt_getConstraintStatus(self)
 
    def setMessageHandler(self, msghandler):
        r"""
        sets the message handler to the user supplied handler.
 
        The pointer to the supplied message handler is stored in the interface object. The user is responsible for the
        creation and destruction of the message handler object.
 
        @param msghandler: a user defined ConoptMessageHandler object
 
 
        @ingroup CONOPTPYTHON_MESSAGEHANDLER
        """
        return libconoptpy4.Conopt_setMessageHandler(self, msghandler)
 
    def sendMessage(self, msg):
        r"""
        sends a message to the message handler
 
        @param msg: A string for the message that will be processed in the message handler
 
 
        @ingroup CONOPTPYTHON_MESSAGEHANDLER
        """
        return libconoptpy4.Conopt_sendMessage(self, msg)
 
    def setVerbosityLevel(self, verblevel):
        r"""
        sets the verbosity level for messaging
 
        The verbosity level is:
          - None -- turn off all output
          - Normal -- normal output, iteration log to stdout and error to stderr
          - Error -- more detailed iteration log to stdout, error to stdout and stderr
          - Debug -- extensive iteration log, error to stdout and stderr
 
        @param verblevel: the verbosity level for the message handler
 
 
        @ingroup CONOPTPYTHON_MESSAGEHANDLER
        """
        return libconoptpy4.Conopt_setVerbosityLevel(self, verblevel)
 
    @staticmethod
    def version():
        r"""
        returns the version number.
 
        It can be used to ensure that the modeler is linked to the correct version of the CONOPT DLL.
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_version()
 
    def debugFV(self, debugfv):
        r"""
        @copydoc DEF_COI_DEBUGFV
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_debugFV(self, debugfv)
 
    def squareModel(self, square):
        r"""
        @copydoc DEF_COI_SQUARE
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_squareModel(self, square)
 
    def setLicense(self, licint1, licint2, licint3, licstring):
        r"""
        @copydoc DEF_COI_LICENSE
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setLicense(self, licint1, licint2, licint3, licstring)
 
    def setItLim(self, itlim):
        r"""
        @copydoc DEF_COI_ITLIM
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setItLim(self, itlim)
 
    def setErrLim(self, errlim):
        r"""
        @copydoc DEF_COI_ERRLIM
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setErrLim(self, errlim)
 
    def fVincLin(self, fvinclin):
        r"""
        @copydoc DEF_COI_FVINCLIN
 
 
        @ingroup REGISTRATION_OF_SIZES_PYTHON
        """
        return libconoptpy4.Conopt_fVincLin(self, fvinclin)
 
    def fVforAll(self, fvforall):
        r"""
        @copydoc DEF_COI_FVFORALL
 
 
        @ingroup REGISTRATION_OF_SIZES_PYTHON
        """
        return libconoptpy4.Conopt_fVforAll(self, fvforall)
 
    def setMaxSup(self, maxsup):
        r"""
        @copydoc DEF_COI_MAXSUP
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setMaxSup(self, maxsup)
 
    def allowEmptyRow(self, emptyrow):
        r"""
        @copydoc DEF_COI_EMPTYROW
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_allowEmptyRow(self, emptyrow)
 
    def allowEmptyCol(self, emptycol):
        r"""
        @copydoc DEF_COI_EMPTYCOL
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_allowEmptyCol(self, emptycol)
 
    def debug2D(self, debug2d):
        r"""
        @copydoc DEF_COI_DEBUG2D
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_debug2D(self, debug2d)
 
    def disCont(self, discont):
        r"""
        @copydoc DEF_COI_DISCONT
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_disCont(self, discont)
 
    def clearM(self, clearm):
        r"""
        @copydoc DEF_COI_CLEARM
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_clearM(self, clearm)
 
    def setResLim(self, reslim):
        r"""
        @copydoc DEF_COI_RESLIM
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setResLim(self, reslim)
 
    def setMaxHeap(self, maxheap):
        r"""
        @copydoc DEF_COI_MAXHEAP
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setMaxHeap(self, maxheap)
 
    def setThreadS(self, threads):
        r"""
        @copydoc DEF_COI_THREADS
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setThreadS(self, threads)
 
    def setThreadF(self, threadf):
        r"""
        @copydoc DEF_COI_THREADF
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setThreadF(self, threadf)
 
    def setThread2D(self, thread2d):
        r"""
        @copydoc DEF_COI_THREAD2D
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setThread2D(self, thread2d)
 
    def setThreadC(self, threadc):
        r"""
        @copydoc DEF_COI_THREADC
 
 
        @ingroup REGISTRATION_OF_OPTIONS_PYTHON
        """
        return libconoptpy4.Conopt_setThreadC(self, threadc)
 
    def getMaxThreads(self):
        r"""
        returns the maximum number of threads that can be used by CONOPT.
 
        If you are using multiple threads it may be necessary to know in advance how many threads CONOPT can use. If
        called inside a parallel loop, this method will return one---indicating that CONOPT cannot use multiple
        threads when CONOPT itself is called in parallel. Therefore, this method should be called in some sequential
        initialization code and not inside a function evaluation routine, that could be called in parallel.
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_getMaxThreads(self)
 
    def getMaxHeapUsed(self):
        r"""
        After a model has been solved this method will return the amount of heap memory used.
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_getMaxHeapUsed(self)
 
    def getRangeErrors(self):
        r"""
        returns the range errors that were encountered.
 
 
        @ingroup UTILITY_ROUTINES_PYTHON
        """
        return libconoptpy4.Conopt_getRangeErrors(self)
 
# Register Conopt in libconoptpy4:
libconoptpy4.Conopt_swigregister(Conopt)
ConstraintType_Eq = libconoptpy4.ConstraintType_Eq
r"""equality constraint"""
ConstraintType_GtEq = libconoptpy4.ConstraintType_GtEq
r"""greater than or equal to constraint"""
ConstraintType_LtEq = libconoptpy4.ConstraintType_LtEq
r"""lesser than or equal to constraint"""
ConstraintType_Free = libconoptpy4.ConstraintType_Free
r"""an unrestricted constraint. This is used when specifying the objective function."""
ObjectiveElement_Variable = libconoptpy4.ObjectiveElement_Variable
r"""the objective is given by a single variable"""
ObjectiveElement_Constraint = libconoptpy4.ObjectiveElement_Constraint
r"""the objective is given by the value of an equation"""
Sense_Minimize = libconoptpy4.Sense_Minimize
r"""a minimisation problem (default)"""
Sense_Maximize = libconoptpy4.Sense_Maximize
r"""a maximisation problem"""
SDEvaluationType__None = libconoptpy4.SDEvaluationType__None
 
SDEvaluationType_Constraint = libconoptpy4.SDEvaluationType_Constraint
 
SDEvaluationType_Lagrangian = libconoptpy4.SDEvaluationType_Lagrangian
 
class Variable(object):
    r"""
    the variable data
 
    This struct is used internally for supplying the variable data to CONOPT. The user is able to query this data from
    the ConoptModelData object. However, the user is not able to change the data after the variable has been added to
    CONOPT.
 
 
    @ingroup QUERY_MODEL_PYTHON
    """
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __init__(self, idx, low, up, cur=0, varstat=-1):
        r"""
        __init__(Variable self, int idx, double low, double up, double cur=0, int varstat=-1) -> Variable
 
        Parameters
        ----------
        idx: int
        low: double
        up: double
        cur: double
        varstat: int
 
        """
        libconoptpy4.Variable_swiginit(self, libconoptpy4.new_Variable(idx, low, up, cur, varstat))
 
    def addNonzero(self, conindex, value, nlflag):
        r"""
        adds a non-zero to the variable data
 
        Notes: this is used internally.
        """
        return libconoptpy4.Variable_addNonzero(self, conindex, value, nlflag)
 
    def sortNonzeros(self):
        r"""
        sorts the non-zeros by constraint index.
 
        Notes: this is used internally.
        """
        return libconoptpy4.Variable_sortNonzeros(self)
    index = property(libconoptpy4.Variable_index_get, libconoptpy4.Variable_index_set, doc=r"""the index of the variable in the problem""")
    lower = property(libconoptpy4.Variable_lower_get, libconoptpy4.Variable_lower_set, doc=r"""the lower bound of the variable""")
    upper = property(libconoptpy4.Variable_upper_get, libconoptpy4.Variable_upper_set, doc=r"""the upper bound of the variable""")
    curr = property(libconoptpy4.Variable_curr_get, libconoptpy4.Variable_curr_set, doc=r"""the initial value of the variable. This is 0 by default.""")
    varstatus = property(libconoptpy4.Variable_varstatus_get, libconoptpy4.Variable_varstatus_set, doc=r"""the initial status of the variable. This depends on the COIDEF_IniStat setting.""")
    consindex_ = property(libconoptpy4.Variable_consindex__get, libconoptpy4.Variable_consindex__set, doc=r"""the index of the constraints""")
    value_ = property(libconoptpy4.Variable_value__get, libconoptpy4.Variable_value__set, doc=r"""the non-zero for linear terms, for non-linear terms this is ignored""")
    nlflag_ = property(libconoptpy4.Variable_nlflag__get, libconoptpy4.Variable_nlflag__set, doc=r"""indicator whether the non-zero is part of a non-linear term""")
    sortorder_ = property(libconoptpy4.Variable_sortorder__get, libconoptpy4.Variable_sortorder__set, doc=r"""a vector to support the sorting of the non-zeros""")
    __swig_destroy__ = libconoptpy4.delete_Variable
 
# Register Variable in libconoptpy4:
libconoptpy4.Variable_swigregister(Variable)
class Constraint(object):
    r"""
    the constraint data
 
    This struct is used internally for supplying the variable data to CONOPT. The user is able to query this data from
    the ConoptModelData object. However, the user is not able to change the data after the variable has been added to
    CONOPT.
 
 
    @ingroup QUERY_MODEL_PYTHON
    """
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __init__(self, idx, type, bound, slackstat):
        r"""
        __init__(Constraint self, int idx, ConoptConstraintType type, double bound, int slackstat) -> Constraint
 
        Parameters
        ----------
        idx: int
        type: enum ConoptConstraintType
        bound: double
        slackstat: int
 
        """
        libconoptpy4.Constraint_swiginit(self, libconoptpy4.new_Constraint(idx, type, bound, slackstat))
    index = property(libconoptpy4.Constraint_index_get, libconoptpy4.Constraint_index_set, doc=r"""the index of the constraint in the problem""")
    constype = property(libconoptpy4.Constraint_constype_get, libconoptpy4.Constraint_constype_set, doc=r"""0: equality, 1: greater than or equal, 2: less than or equal, 3: free row""")
    rhs = property(libconoptpy4.Constraint_rhs_get, libconoptpy4.Constraint_rhs_set, doc=r"""the right hand side of the constraint""")
    slackstatus = property(libconoptpy4.Constraint_slackstatus_get, libconoptpy4.Constraint_slackstatus_set, doc=r"""the initial status of the slacks. This depends on the COIDEF_IniStat setting.""")
    __swig_destroy__ = libconoptpy4.delete_Constraint
 
# Register Constraint in libconoptpy4:
libconoptpy4.Constraint_swigregister(Constraint)
class ConoptModelData(object):
    r"""The Model Data class"""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __init__(self):
        r"""Constructor"""
        if self.__class__ == ConoptModelData:
            _self = None
        else:
            _self = self
        libconoptpy4.ConoptModelData_swiginit(self, libconoptpy4.new_ConoptModelData(_self, ))
    __swig_destroy__ = libconoptpy4.delete_ConoptModelData
 
    def readMatrix(self, lower, curr, upper, vsta, type, rhs, esta, colsta, rowno, value, nlflag, numvar, numcon, numnz):
        r"""
        loads the structure of the model into CONOPT.
 
        Using the C++ interface, there are two ways to load the model into CONOPT.
        The first method follows the process used for the Fortran and C interfaces. This involves:
        1. setting the problem dimension by calling setProblemDimension().
        2. set the objective element (constraint or variable) by calling setObjectiveElement().
        3. set the optimisation sense by calling setOptimizationSense().
        4. implementing a readMatrix() method that loads the model using a column-oriented sparse matrix format. For
           more details regarding the parameters of the readMatrix() method, please see 'API_DEFINING_THE_MODEL_F90'
 
        The second method makes use of the convenience functions included in the C++ interface. Within the
        ConoptModelData the methods addConstraint() and addVariable() are provided. As such, to load the model into
        CONOPT, you must:
        1. write a member function for building the model.
        2. in the build model function, call addVariable() for each variable to be added to the problem.
        3. in the build model function, call addConstraint() for each constraint to be added to the problem. When adding
           a constraint, you should specify the variables (by index), coefficients and non-linear flags (for all
           nonlinear terms).
        4. set the objective element (constraint or variable) by calling setObjectiveElement().
        5. set the optimisation sense by calling setOptimizationSense().
        When the solve method is called, the default readMatrix() method will be called, which will load the model into
        CONOPT as specified by the calls to addVariable() and addConstraint().
 
 
        """
        return libconoptpy4.ConoptModelData_readMatrix(self, lower, curr, upper, vsta, type, rhs, esta, colsta, rowno, value, nlflag, numvar, numcon, numnz)
 
    def setProblemDimension(self, numvar, numcons, numnz, numnlnz):
        r"""
         sets the problem dimension. This is called if the user wants to implement a custom readMatrix() method.
 
         NOTE: it is not possible to call setProblemDimension() and addConstraint() or addVariable(). The latter
         functions can only be used if the problem dimension is not set and the default readMatrix() method is used.
 
 
 
        @param numvar: the number of variables in the problem
        @param numcons: the number of constraints in the problem
        @param numnz: the number of non-zeros in the constraint matrix
        @param numnlnz: the number of nonlinear non-zeros in the constraint matrix
        """
        return libconoptpy4.ConoptModelData_setProblemDimension(self, numvar, numcons, numnz, numnlnz)
 
    def addConstraint(self, *args):
        r"""
        *Overload 1:*
         adds a constraint to the problem. The non-zero coefficients are added later
 
 
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param slackstatus: initial status of the slack variables, see IniStat
 
        |
 
        *Overload 2:*
         adds a constraint to the problem. The matrix non-zeros are added based on the supplied variables
 
 
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param varindex: the variables this constraint has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param slackstatus: initial status of the slack variables, see IniStat
 
        |
 
        *Overload 3:*
         adds a constraint to the problem. The matrix non-zeros are added based on the supplied variables
 
 
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param varindex: the variables this constraint has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param slackstatus: initial status of the slack variables, see IniStat
        """
        return libconoptpy4.ConoptModelData_addConstraint(self, *args)
 
    def addVariable(self, *args):
        r"""
        *Overload 1:*
         adds a variable to the model. The non-zero coefficients are added later.
 
 
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 2:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 3:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 4:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
        """
        return libconoptpy4.ConoptModelData_addVariable(self, *args)
 
    def setObjectiveElement(self, elem, elemindex):
        r"""
        sets the index for the objective variable or constraint
 
 
        """
        return libconoptpy4.ConoptModelData_setObjectiveElement(self, elem, elemindex)
 
    def setOptimizationSense(self, sense):
        r"""
        sets the optimisation direction.
 
 
        """
        return libconoptpy4.ConoptModelData_setOptimizationSense(self, sense)
 
    def setInitialStatusOption(self, inistat):
        r"""
        the setting to indicate how the initial status of the variables and slack variables will be handled.
 
        The initial status is set in the addVariable() and addConstraint() methods, or in the readMatrix() method if the
        classical model input approach is used. By default, the value of inistat is 0, which means that the variable and
        slack status is ignored.
 
        If inistat == 1:
          The variable status has the following behaviour:
          - 0: The variable is initialized non-basic (if curr = lower or curr = upper) or super-basic, and
          - 1: The variable is initialized basic
          The slack status has the following behaviour:
          - 0: The slack is initialized non-basic (if the constraint is binding in the initial point) or super-basic,
          - 1: The slack is initialized basic
 
        If inistat == 2:
          The variable status has the following behaviour:
          - 0: The variable is initialized at lower bound
          - 1: The variable is initialized at upper bound
          - 2: The variable is initialized basic, and
          - 3: The variable is initialized superbasic.
          The slack status has the following behaviour:
          - 0: The slack is initialized at lower bound.
          - 1: The slack is initialized at upper bound.
          - 2: The slack is initialized basic, and
          - 3: The slack is initialized superbasic.
 
 
        """
        return libconoptpy4.ConoptModelData_setInitialStatusOption(self, inistat)
 
    def numVar(self):
        r"""
        returns the number of variables in the model
 
 
        """
        return libconoptpy4.ConoptModelData_numVar(self)
 
    def numCons(self):
        r"""
        returns the number of constraints in the model
 
 
        """
        return libconoptpy4.ConoptModelData_numCons(self)
 
    def numHessianNonzeros(self):
        r"""
        returns the number of non-zeros in the Hessian
 
 
        """
        return libconoptpy4.ConoptModelData_numHessianNonzeros(self)
 
    def getVariable(self, *args):
        r"""
        *Overload 1:*
        returns a reference to the variable object
 
 
 
        |
 
        *Overload 2:*
        returns a reference to the variable object
 
 
        """
        return libconoptpy4.ConoptModelData_getVariable(self, *args)
 
    def getConstraint(self, *args):
        r"""
        *Overload 1:*
        returns a reference to the constraint object
 
 
 
        |
 
        *Overload 2:*
        returns a reference to the constraint object
 
 
        """
        return libconoptpy4.ConoptModelData_getConstraint(self, *args)
 
    def setSDEvaluationType(self, sdevaltype):
        r"""
        informs CONOPT of the method for evaluating the second derivative
 
 
        """
        return libconoptpy4.ConoptModelData_setSDEvaluationType(self, sdevaltype)
 
    def setSDLagrangianStructure(self, rownum, colnum):
        r"""
         sets the structure of the second derivatives of the Lagrangian
 
 
 
        @param rownum: Vector of row numbers of the lower triangular part of the Hessian.
        @param colnum: Vector of column numbers of the lower triangular part of the Hessian.
        """
        return libconoptpy4.ConoptModelData_setSDLagrangianStructure(self, rownum, colnum)
 
    def getSDLagrangianRowNumbers(self):
        r"""returns the row numbers in the second derivative of the lagrangian structure"""
        return libconoptpy4.ConoptModelData_getSDLagrangianRowNumbers(self)
 
    def getSDLagrangianColumnNumbers(self):
        r"""returns the column numbers in the second derivative of the lagrangian structure"""
        return libconoptpy4.ConoptModelData_getSDLagrangianColumnNumbers(self)
    def __disown__(self):
        self.this.disown()
        libconoptpy4.disown_ConoptModelData(self)
        return weakref.proxy(self)
 
# Register ConoptModelData in libconoptpy4:
libconoptpy4.ConoptModelData_swigregister(ConoptModelData)
VerbosityLevel_VerbLevelMin = libconoptpy4.VerbosityLevel_VerbLevelMin
 
VerbosityLevel__None = libconoptpy4.VerbosityLevel__None
r"""turn off all output"""
VerbosityLevel_Normal = libconoptpy4.VerbosityLevel_Normal
r"""normal output, iteration log to stdout and error to stderr"""
VerbosityLevel_Error = libconoptpy4.VerbosityLevel_Error
r"""more detailed iteration log to stdout, error to stdout and stderr"""
VerbosityLevel_Debug = libconoptpy4.VerbosityLevel_Debug
r"""extensive iteration log, error to stdout and stderr"""
VerbosityLevel_VerbLevelMax = libconoptpy4.VerbosityLevel_VerbLevelMax
 
class ConoptAlgProgress(object):
    r"""Proxy of C++ ConoptAlgProgress class."""
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    iteration = property(libconoptpy4.ConoptAlgProgress_iteration_get, libconoptpy4.ConoptAlgProgress_iteration_set, doc=r"""Number of the iteration.""")
    phase = property(libconoptpy4.ConoptAlgProgress_phase_get, libconoptpy4.ConoptAlgProgress_phase_set, doc=r"""The phase of the optimization.""")
    numinfeas = property(libconoptpy4.ConoptAlgProgress_numinfeas_get, libconoptpy4.ConoptAlgProgress_numinfeas_set, doc=r"""
    Number of infeasible constraints. In phase 0, this number will only
                                                     count the number of "difficult" constraints.
    """)
    numnopt = property(libconoptpy4.ConoptAlgProgress_numnopt_get, libconoptpy4.ConoptAlgProgress_numnopt_set, doc=r"""
    Number of non-optimal variables. Will be 0 meaning undefined
                                                     during phase 0.
    """)
    numsuper = property(libconoptpy4.ConoptAlgProgress_numsuper_get, libconoptpy4.ConoptAlgProgress_numsuper_set, doc=r"""Number of super-basic variables. Will be zero during phase 0 .""")
    suminfeas = property(libconoptpy4.ConoptAlgProgress_suminfeas_get, libconoptpy4.ConoptAlgProgress_suminfeas_set, doc=r"""
    Sum of the infeasibilities. In phase 0 it will include the
                                                     infeasibilities in both easy and difficult constraint. During phase
                                                     3 and 4 SUMINF will be 0.
    """)
    objvalue = property(libconoptpy4.ConoptAlgProgress_objvalue_get, libconoptpy4.ConoptAlgProgress_objvalue_set, doc=r"""
    The value of the true objective function. OBJVAL is zero meaning
                                                     undefined during phase 0, 1 and 2
    """)
    rgmax = property(libconoptpy4.ConoptAlgProgress_rgmax_get, libconoptpy4.ConoptAlgProgress_rgmax_set, doc=r"""
    The numerically largest reduced gradient. RGMAX will be zero during
                                                     phase 0
    """)
    step = property(libconoptpy4.ConoptAlgProgress_step_get, libconoptpy4.ConoptAlgProgress_step_set, doc=r"""The optimal steplength.""")
    numvar = property(libconoptpy4.ConoptAlgProgress_numvar_get, libconoptpy4.ConoptAlgProgress_numvar_set, doc=r"""The number of variables""")
 
    def __init__(self):
        r"""__init__(ConoptAlgProgress self) -> ConoptAlgProgress"""
        libconoptpy4.ConoptAlgProgress_swiginit(self, libconoptpy4.new_ConoptAlgProgress())
    __swig_destroy__ = libconoptpy4.delete_ConoptAlgProgress
 
# Register ConoptAlgProgress in libconoptpy4:
libconoptpy4.ConoptAlgProgress_swigregister(ConoptAlgProgress)
class MessageHandler(object):
    r"""
    The message handler class
 
    @ingroup MESSAGEHANDLER_PYTHON
    """
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __init__(self):
        r"""Constructor"""
        if self.__class__ == MessageHandler:
            _self = None
        else:
            _self = self
        libconoptpy4.MessageHandler_swiginit(self, libconoptpy4.new_MessageHandler(_self, ))
    __swig_destroy__ = libconoptpy4.delete_MessageHandler
 
    def message(self, smsg, dmsg, nmsg, msgv):
        r"""
         virtual method for handling the messages.
 
         This can be redefined by the user for alternative message handling
 
          @include{doc} message_cb_intro.dox
 
 
         @ingroup MESSAGEHANDLER_PYTHON
 
        @param smsg: The number of lines in the message that should go to the Screen file. Between 0 and 30.
        @param dmsg: The number of lines in the message that should go to the Status file. Between 0 and 30.
        @param nmsg: The number of lines in the message that should go to the Documentation file. Between 0 and 30.
        @param msgv: Vector with the actual message lines.
        """
        return libconoptpy4.MessageHandler_message(self, smsg, dmsg, nmsg, msgv)
 
    def errorMessage(self, rowno, colno, posno, msg):
        r"""
         virtual method for handling error messages.
 
         This can be redefined by the user for alternative message handling
 
         Messages about particular parts of a model are all one line long. The messages
         can be related to an error or it can be a general informative message related to
         a row or column or Jacobian element. The modeler is responsible for combining
         the row and column identification and the message text and for displaying the
         overall message.
 
         There are some special cases for the three first arguments and the message
         should be interpreted accordingly. The special cases are:
 
         - **COLNO = -1:** The message is about a row and `ROWNO` will be between 0
         and `NumCon-1`.
 
         - **ROWNO = -1:** The message is about a column and `COLNO` will be between 0
         and `NumVar-1`.
 
         - **ROWNO and COLNO both non-negative:** The message is about a position in
         the Jacobian if `POSNO` is non-negative and about a (row,column)-pair if `POSNO`
         is -1.
 
         Examples of message texts are "Inconsistent lower and upper bounds." and "The
         variable has reached 'infinity.'" for a column, "The slack has reached
         'infinity.'" for a row and "Initial Jacobian element was not defined." for a
         Jacobian element.
 
 
         @ingroup MESSAGEHANDLER_PYTHON
 
        @param rowno: The number of a row in the matrix.
        @param colno: The number of a column in the matrix.
        @param posno: The number of a Jacobian element in the matrix.
        @param msg: The actual message.
        """
        return libconoptpy4.MessageHandler_errorMessage(self, rowno, colno, posno, msg)
 
    def progress(self, progressdata):
        r"""
        progress(MessageHandler self, ConoptAlgProgress progressdata) -> int
 
        Parameters
        ----------
        progressdata: ConoptAlgProgress const &
 
        """
        return libconoptpy4.MessageHandler_progress(self, progressdata)
 
    def sendMessage(self, msg):
        r"""
        sends a message to the message handler
 
 
        @ingroup MESSAGEHANDLER_PYTHON
        """
        return libconoptpy4.MessageHandler_sendMessage(self, msg)
 
    def setVerbosityLevel(self, verblevel):
        r"""
        sets the verbosity level for messaging.
 
        The effect of this will depend on how the user implements the custom message handler
 
 
        @ingroup MESSAGEHANDLER_PYTHON
        """
        return libconoptpy4.MessageHandler_setVerbosityLevel(self, verblevel)
    def __disown__(self):
        self.this.disown()
        libconoptpy4.disown_MessageHandler(self)
        return weakref.proxy(self)
 
# Register MessageHandler in libconoptpy4:
libconoptpy4.MessageHandler_swigregister(MessageHandler)
EvaluationMode_TermsOnly = libconoptpy4.EvaluationMode_TermsOnly
r"""only the nonlinear terms will be evaluated."""
EvaluationMode_JacobianOnly = libconoptpy4.EvaluationMode_JacobianOnly
r"""only the Jacobian of the nonlinear terms will be evaluated."""
EvaluationMode_Both = libconoptpy4.EvaluationMode_Both
r"""both the nonlinear terms and Jacobian will be evaluated."""
class ModelData(ConoptModelData):
    r"""
    A class that can be extended to build and solve a model using Conopt.
 
    This class is the base class that is used for the extended interfaces for Conopt, namely Python and Java. The
    virtual methods included in this class can be redefined in the native languages.
 
    @ingroup MODELDATA_PYTHON
    """
 
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
 
    def __init__(self):
        r"""
        __init__(ModelData self) -> ModelData
 
        Parameters
        ----------
        self: PyObject *
 
        """
        if self.__class__ == ModelData:
            _self = None
        else:
            _self = self
        libconoptpy4.ModelData_swiginit(self, libconoptpy4.new_ModelData(_self, ))
    __swig_destroy__ = libconoptpy4.delete_ModelData
 
    def evaluateNonlinearTerm(self, x, rowno, ignerr, thread):
        r"""
        callback method for evaluating the nonlinear terms in a given row
 
        @param x: the solution vector that needs to be evaluated.
        @param rowno: the number for the row in which the nonlinear term exists.
        @param ignerr: a boolean to indicate whether the current point is safe or unsafe.
        @param thread: the index of the thread from which this method is being called from.
 
        @return the value of the nonlinear terms.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup EVAL_NONLINEAR_FUNCTION_PYTHON
        """
        return libconoptpy4.ModelData_evaluateNonlinearTerm(self, x, rowno, ignerr, thread)
 
    def evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread):
        r"""
        callback method for evaluating the jacobian for the nonlinear terms in a given row
 
        @param x: the solution vector that needs to be evaluated.
        @param rowno: the number for the row in which the nonlinear term exists.
        @param jacnum: vector with a list of column numbers for the nonlinear nonzero Jacobian elements in the row.
        @param ignerr: a boolean to indicate whether the current point is safe or unsafe.
        @param thread: the index of the thread from which this method is being called from.
 
        @return a vector the length of jacnum that contains the jacobian values for the referenced elements.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup EVAL_NONLINEAR_FUNCTION_PYTHON
        """
        return libconoptpy4.ModelData_evaluateNonlinearJacobian(self, x, rowno, jacnum, ignerr, thread)
 
    def initFDEvaluation(self, x, rowlist, mode, numthread, ignerr):
        r"""
        callback method for initialising the first derivative evaluation.
 
        If defined, this method will be called each time the point of interest
        has changed, and it will define the coming point and tell which constraints
        CONOPT will need during the following calls to `evaluateNonlinearTerm` and `evaluateNonlinearJacobian`.
 
        @param x: the solution vector that needs to be evaluated.
        @param rowlist: the list of rows that will be evaluated for the given point.
        @param mode: the evaluation mode for the current iteration. This is either TermsOnly, JacobianOnly or Both. See
           EvaluationMode for more details.
        @param numthread: the number of threads that will be used for the following FDEval calls.
        @param ignerr: a boolean to indicate whether the current point is safe or unsafe.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
        """
        pass
 
 
 
    def endFDEvaluation(self, ignerr):
        r"""
        Optional function, if defined, it will be called at the end of the function evaluation stage.
        This can be used to clean up any user data generated, such as in `FDEvalIni`, that was used to improve
        the efficiency of the function and derivative evaluation.
 
        @param ignerr: a boolean to indicate whether the current point is safe or unsafe.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup EVAL_NONLINEAR_FUNCTION_PYTHON
        """
        return libconoptpy4.ModelData_endFDEvaluation(self, ignerr)
 
    def evaluateSDLagrangian(self, x, u, hessianrow, hessiancol):
        r"""
        Computes and returns the numerical values of the Lagrangian of the Hessian
 
        @param x: the solution vector that needs to be evaluated.
        @param u: the vector of weights on the individual constraints.
        @param hessianrow: vector of row numbers of the lower triangular part of the hessian.
        @param hessiancol: vector of column numbers of the lower triangular part of the hessian.
 
        returns a vector for the values of the Lagrangian of the Hessian. The length of the vector is of size numHessianNonzeros().
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
        """
        return libconoptpy4.ModelData_evaluateSDLagrangian(self, x, u, hessianrow, hessiancol)
 
    def evaluateSDDirLagrangian(self, x, dx, u, newpoint):
        r"""
        computes the directional second derivative for the Lagrangian
 
        @param x: the solution vector that needs to be evaluated.
        @param dx: vector with the direction in which the directional second derivatives should be computed.
        @param u: the vector of weights on the individual constraints.
        @param newpoint: a boolean to indicate whether x has changed. If newpoint is false, the values of dx may have
                   changed.
 
        returns a vector for the directional second derivative. The length of the vector is the number of variables.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
        """
        return libconoptpy4.ModelData_evaluateSDDirLagrangian(self, x, dx, u, newpoint)
 
    def evaluateDirectionalSD(self, x, dx, rowno, jacnum, thread):
        r"""
        computes the directional second derivative for a single constraint
 
        @param x: the solution vector that needs to be evaluated.
        @param dx: vector with the direction in which the directional second derivatives should be computed.
        @param rowno: the number for the row in which the nonlinear term exists.
        @param jacnum: vector with a list of column numbers for the nonlinear nonzero Jacobian elements in the row.
        @param thread: the index of the thread from which this method is being called from.
 
        returns a vector for the directional second derivative. The length of the vector is the number of variables.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
        """
        return libconoptpy4.ModelData_evaluateDirectionalSD(self, x, dx, rowno, jacnum, thread)
 
    def initDirectionalSDEval(self, x, dx, rowlist, numthread, newpoint):
        r"""
        a callback for the initialisation of the second derivative evaluation.
 
        This method is called before a sequence of calls to evaluateDirectionalSD(). The user can utilise this method
        for evaluating common terms and storing important information.
 
        @param x: the solution vector that needs to be evaluated.
        @param dx: vector with the direction in which the directional second derivatives should be computed.
        @param rowlist: the list of rows that will be evaluated for the given point.
        @param numthread: the number of threads that will be used for the following FDEval calls.
        @param newpoint: a boolean to indicate whether x has changed. If newpoint is false, the values of dx may have
                   changed.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
        """
        pass
 
 
 
    def endDirectionalSDEval(self):
        r"""
        called by CONOPT after a sequence of evaluateDirectionalSD() calls each time either the point or the direction
        changes.
 
        It can be used to perform cleanup tasks, including to report if anything went wrong.
 
        Notes: an error in the evaluation is reported by calling errorInEvaluation()
 
        @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
        """
        return libconoptpy4.ModelData_endDirectionalSDEval(self)
 
    def errorInEvaluation(self):
        r"""
        reports that an error occurred in the evaluation.
 
        When executing evaluateNonlinearTerm() or evaluateNonlinearJacobian() the number of errors are counted and then
        if an error limit is exceeded, CONOPT will terminate.
 
        When evaluating second derivative information, any errors reported will inform CONOPT that it is unable to use
        second order methods for the current point.
        """
        return libconoptpy4.ModelData_errorInEvaluation(self)
 
    def setProblemDimension(self, numvar, numcons, numnz, numnlnz):
        r"""
         sets the problem dimension. This is called if the user wants to implement a custom readMatrix() method.
 
         NOTE: it is not possible to call setProblemDimension() and addConstraint() or addVariable(). The latter
         functions can only be used if the problem dimension is not set and the default readMatrix() method is used.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param numvar: the number of variables in the problem
        @param numcons: the number of constraints in the problem
        @param numnz: the number of non-zeros in the constraint matrix
        @param numnlnz: the number of nonlinear non-zeros in the constraint matrix
        """
        return libconoptpy4.ModelData_setProblemDimension(self, numvar, numcons, numnz, numnlnz)
 
    def addConstraint(self, *args):
        r"""
        *Overload 1:*
         adds a constraint to the problem. The non-zero coefficients are added later
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param slackstatus: initial status of the slack variables, see IniStat
 
        |
 
        *Overload 2:*
         adds a constraint to the problem. The non-zero coefficients are added later
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param slackstatus: initial status of the slack variables, see IniStat
 
        |
 
        *Overload 3:*
         adds a constraint to the problem. The matrix non-zeros are added based on the supplied variables
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param varindex: the variables this constraint has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param slackstatus: initial status of the slack variables, see IniStat
 
        |
 
        *Overload 4:*
         adds a constraint to the problem. The matrix non-zeros are added based on the supplied variables
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param constype: the type of constraint, 0: ==, 1: >=, 2: <=, 3: free
        @param rhs: the right hand side
        @param varindex: the variables this constraint has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param slackstatus: initial status of the slack variables, see IniStat
        """
        return libconoptpy4.ModelData_addConstraint(self, *args)
 
    def addVariable(self, *args):
        r"""
        *Overload 1:*
         adds a variable to the model. The non-zero coefficients are added later.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 2:*
         adds a variable to the model. The non-zero coefficients are added later.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 3:*
         adds a variable to the model. The non-zero coefficients are added later.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 4:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 5:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
 
        |
 
        *Overload 6:*
         adds a variable to the problem. The matrix non-zeros are added based on the supplied constraints.
 
 
         @ingroup DEFINE_MODEL_PYTHON
 
        @param lower: lower bound for the variable
        @param upper: upper bound for the variable
        @param consindex: the constraints this variable has non-zero coefficients
        @param value: the non-zero of the variable
        @param nlflag: flag to set whether the variable belongs to a non-linear term
        @param curr: initial value of the variable, can be set to 0
        @param varstatus: initial status of the variable, see IniStat
        """
        return libconoptpy4.ModelData_addVariable(self, *args)
 
    def setObjectiveElement(self, elem, elemindex):
        r"""
        sets the index for the objective variable or constraint
 
 
        @ingroup DEFINE_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_setObjectiveElement(self, elem, elemindex)
 
    def setOptimizationSense(self, sense):
        r"""
        sets the optimisation direction.
 
 
        @ingroup DEFINE_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_setOptimizationSense(self, sense)
 
    def setInitialStatusOption(self, inistat):
        r"""
        the setting to indicate how the initial status of the variables and slack variables will be handled.
 
        The initial status is set in the addVariable() and addConstraint() methods, or in the readMatrix() method if the
        classical model input approach is used. By default, the value of inistat is 0, which means that the variable and
        slack status is ignored.
 
        If inistat == 1:
          The variable status has the following behaviour:
          - 0: The variable is initialized non-basic (if curr = lower or curr = upper) or super-basic, and
          - 1: The variable is initialized basic
          The slack status has the following behaviour:
          - 0: The slack is initialized non-basic (if the constraint is binding in the initial point) or super-basic,
          - 1: The slack is initialized basic
 
        If inistat == 2:
          The variable status has the following behaviour:
          - 0: The variable is initialized at lower bound
          - 1: The variable is initialized at upper bound
          - 2: The variable is initialized basic, and
          - 3: The variable is initialized superbasic.
          The slack status has the following behaviour:
          - 0: The slack is initialized at lower bound.
          - 1: The slack is initialized at upper bound.
          - 2: The slack is initialized basic, and
          - 3: The slack is initialized superbasic.
 
 
        @ingroup DEFINE_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_setInitialStatusOption(self, inistat)
 
    def numVar(self):
        r"""
        returns the number of variables in the model
 
 
        @ingroup QUERY_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_numVar(self)
 
    def numCons(self):
        r"""
        returns the number of constraints in the model
 
 
        @ingroup QUERY_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_numCons(self)
 
    def numHessianNonzeros(self):
        r"""
        returns the number of non-zeros in the Hessian
 
 
        @ingroup QUERY_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_numHessianNonzeros(self)
 
    def getVariable(self, *args):
        r"""
        *Overload 1:*
        returns a reference to the variable object
 
 
        @ingroup QUERY_MODEL_PYTHON
 
        |
 
        *Overload 2:*
        returns a reference to the variable object
 
 
        @ingroup QUERY_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_getVariable(self, *args)
 
    def getConstraint(self, *args):
        r"""
        *Overload 1:*
        returns a reference to the constraint object
 
 
        @ingroup QUERY_MODEL_PYTHON
 
        |
 
        *Overload 2:*
        returns a reference to the constraint object
 
 
        @ingroup QUERY_MODEL_PYTHON
        """
        return libconoptpy4.ModelData_getConstraint(self, *args)
 
    def setSDEvaluationType(self, sdevaltype):
        r"""
        informs CONOPT of the method for evaluating the second derivative
 
 
        @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
        """
        return libconoptpy4.ModelData_setSDEvaluationType(self, sdevaltype)
 
    def setSDLagrangianStructure(self, rownum, colnum):
        r"""
         sets the structure of the second derivatives of the Lagrangian
 
 
         @ingroup DEFINE_SECOND_DERIVATIVE_PYTHON
 
        @param rownum: Vector of row numbers of the lower triangular part of the Hessian.
        @param colnum: Vector of column numbers of the lower triangular part of the Hessian.
        """
        return libconoptpy4.ModelData_setSDLagrangianStructure(self, rownum, colnum)
    def __disown__(self):
        self.this.disown()
        libconoptpy4.disown_ModelData(self)
        return weakref.proxy(self)
 
# Register ModelData in libconoptpy4:
libconoptpy4.ModelData_swigregister(ModelData)