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

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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


class SwigPyIterator(object):
    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__ = _fityk.delete_SwigPyIterator

    def value(self):
        r"""value(SwigPyIterator self) -> PyObject *"""
        return _fityk.SwigPyIterator_value(self)

    def incr(self, n=1):
        r"""incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _fityk.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        r"""decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator"""
        return _fityk.SwigPyIterator_decr(self, n)

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

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

    def copy(self):
        r"""copy(SwigPyIterator self) -> SwigPyIterator"""
        return _fityk.SwigPyIterator_copy(self)

    def next(self):
        r"""next(SwigPyIterator self) -> PyObject *"""
        return _fityk.SwigPyIterator_next(self)

    def __next__(self):
        r"""__next__(SwigPyIterator self) -> PyObject *"""
        return _fityk.SwigPyIterator___next__(self)

    def previous(self):
        r"""previous(SwigPyIterator self) -> PyObject *"""
        return _fityk.SwigPyIterator_previous(self)

    def advance(self, n):
        r"""advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _fityk.SwigPyIterator_advance(self, n)

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

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

    def __iadd__(self, n):
        r"""__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _fityk.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        r"""__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _fityk.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        r"""__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _fityk.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        r"""
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _fityk.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

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

class PointVector(object):
    r"""Proxy of C++ std::vector< fityk::Point > 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(PointVector self) -> SwigPyIterator"""
        return _fityk.PointVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(PointVector self) -> bool"""
        return _fityk.PointVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(PointVector self) -> bool"""
        return _fityk.PointVector___bool__(self)

    def __len__(self):
        r"""__len__(PointVector self) -> std::vector< fityk::Point >::size_type"""
        return _fityk.PointVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(PointVector self, std::vector< fityk::Point >::difference_type i, std::vector< fityk::Point >::difference_type j) -> PointVector"""
        return _fityk.PointVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(PointVector self, std::vector< fityk::Point >::difference_type i, std::vector< fityk::Point >::difference_type j)
        __setslice__(PointVector self, std::vector< fityk::Point >::difference_type i, std::vector< fityk::Point >::difference_type j, PointVector v)
        """
        return _fityk.PointVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(PointVector self, std::vector< fityk::Point >::difference_type i, std::vector< fityk::Point >::difference_type j)"""
        return _fityk.PointVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(PointVector self, std::vector< fityk::Point >::difference_type i)
        __delitem__(PointVector self, PySliceObject * slice)
        """
        return _fityk.PointVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(PointVector self, PySliceObject * slice) -> PointVector
        __getitem__(PointVector self, std::vector< fityk::Point >::difference_type i) -> Point
        """
        return _fityk.PointVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(PointVector self, PySliceObject * slice, PointVector v)
        __setitem__(PointVector self, PySliceObject * slice)
        __setitem__(PointVector self, std::vector< fityk::Point >::difference_type i, Point x)
        """
        return _fityk.PointVector___setitem__(self, *args)

    def pop(self):
        r"""pop(PointVector self) -> Point"""
        return _fityk.PointVector_pop(self)

    def append(self, x):
        r"""append(PointVector self, Point x)"""
        return _fityk.PointVector_append(self, x)

    def empty(self):
        r"""empty(PointVector self) -> bool"""
        return _fityk.PointVector_empty(self)

    def size(self):
        r"""size(PointVector self) -> std::vector< fityk::Point >::size_type"""
        return _fityk.PointVector_size(self)

    def swap(self, v):
        r"""swap(PointVector self, PointVector v)"""
        return _fityk.PointVector_swap(self, v)

    def begin(self):
        r"""begin(PointVector self) -> std::vector< fityk::Point >::iterator"""
        return _fityk.PointVector_begin(self)

    def end(self):
        r"""end(PointVector self) -> std::vector< fityk::Point >::iterator"""
        return _fityk.PointVector_end(self)

    def rbegin(self):
        r"""rbegin(PointVector self) -> std::vector< fityk::Point >::reverse_iterator"""
        return _fityk.PointVector_rbegin(self)

    def rend(self):
        r"""rend(PointVector self) -> std::vector< fityk::Point >::reverse_iterator"""
        return _fityk.PointVector_rend(self)

    def clear(self):
        r"""clear(PointVector self)"""
        return _fityk.PointVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(PointVector self) -> std::vector< fityk::Point >::allocator_type"""
        return _fityk.PointVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(PointVector self)"""
        return _fityk.PointVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(PointVector self, std::vector< fityk::Point >::iterator pos) -> std::vector< fityk::Point >::iterator
        erase(PointVector self, std::vector< fityk::Point >::iterator first, std::vector< fityk::Point >::iterator last) -> std::vector< fityk::Point >::iterator
        """
        return _fityk.PointVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(PointVector self) -> PointVector
        __init__(PointVector self, PointVector other) -> PointVector
        __init__(PointVector self, std::vector< fityk::Point >::size_type size) -> PointVector
        __init__(PointVector self, std::vector< fityk::Point >::size_type size, Point value) -> PointVector
        """
        _fityk.PointVector_swiginit(self, _fityk.new_PointVector(*args))

    def push_back(self, x):
        r"""push_back(PointVector self, Point x)"""
        return _fityk.PointVector_push_back(self, x)

    def front(self):
        r"""front(PointVector self) -> Point"""
        return _fityk.PointVector_front(self)

    def back(self):
        r"""back(PointVector self) -> Point"""
        return _fityk.PointVector_back(self)

    def assign(self, n, x):
        r"""assign(PointVector self, std::vector< fityk::Point >::size_type n, Point x)"""
        return _fityk.PointVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(PointVector self, std::vector< fityk::Point >::size_type new_size)
        resize(PointVector self, std::vector< fityk::Point >::size_type new_size, Point x)
        """
        return _fityk.PointVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(PointVector self, std::vector< fityk::Point >::iterator pos, Point x) -> std::vector< fityk::Point >::iterator
        insert(PointVector self, std::vector< fityk::Point >::iterator pos, std::vector< fityk::Point >::size_type n, Point x)
        """
        return _fityk.PointVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(PointVector self, std::vector< fityk::Point >::size_type n)"""
        return _fityk.PointVector_reserve(self, n)

    def capacity(self):
        r"""capacity(PointVector self) -> std::vector< fityk::Point >::size_type"""
        return _fityk.PointVector_capacity(self)
    __swig_destroy__ = _fityk.delete_PointVector

# Register PointVector in _fityk:
_fityk.PointVector_swigregister(PointVector)

class RealVector(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(RealVector self) -> SwigPyIterator"""
        return _fityk.RealVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(RealVector self) -> bool"""
        return _fityk.RealVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(RealVector self) -> bool"""
        return _fityk.RealVector___bool__(self)

    def __len__(self):
        r"""__len__(RealVector self) -> std::vector< double >::size_type"""
        return _fityk.RealVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(RealVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> RealVector"""
        return _fityk.RealVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(RealVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(RealVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, RealVector v)
        """
        return _fityk.RealVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(RealVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _fityk.RealVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(RealVector self, std::vector< double >::difference_type i)
        __delitem__(RealVector self, PySliceObject * slice)
        """
        return _fityk.RealVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(RealVector self, PySliceObject * slice) -> RealVector
        __getitem__(RealVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _fityk.RealVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(RealVector self, PySliceObject * slice, RealVector v)
        __setitem__(RealVector self, PySliceObject * slice)
        __setitem__(RealVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _fityk.RealVector___setitem__(self, *args)

    def pop(self):
        r"""pop(RealVector self) -> std::vector< double >::value_type"""
        return _fityk.RealVector_pop(self)

    def append(self, x):
        r"""append(RealVector self, std::vector< double >::value_type const & x)"""
        return _fityk.RealVector_append(self, x)

    def empty(self):
        r"""empty(RealVector self) -> bool"""
        return _fityk.RealVector_empty(self)

    def size(self):
        r"""size(RealVector self) -> std::vector< double >::size_type"""
        return _fityk.RealVector_size(self)

    def swap(self, v):
        r"""swap(RealVector self, RealVector v)"""
        return _fityk.RealVector_swap(self, v)

    def begin(self):
        r"""begin(RealVector self) -> std::vector< double >::iterator"""
        return _fityk.RealVector_begin(self)

    def end(self):
        r"""end(RealVector self) -> std::vector< double >::iterator"""
        return _fityk.RealVector_end(self)

    def rbegin(self):
        r"""rbegin(RealVector self) -> std::vector< double >::reverse_iterator"""
        return _fityk.RealVector_rbegin(self)

    def rend(self):
        r"""rend(RealVector self) -> std::vector< double >::reverse_iterator"""
        return _fityk.RealVector_rend(self)

    def clear(self):
        r"""clear(RealVector self)"""
        return _fityk.RealVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(RealVector self) -> std::vector< double >::allocator_type"""
        return _fityk.RealVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(RealVector self)"""
        return _fityk.RealVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(RealVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(RealVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _fityk.RealVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(RealVector self) -> RealVector
        __init__(RealVector self, RealVector other) -> RealVector
        __init__(RealVector self, std::vector< double >::size_type size) -> RealVector
        __init__(RealVector self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> RealVector
        """
        _fityk.RealVector_swiginit(self, _fityk.new_RealVector(*args))

    def push_back(self, x):
        r"""push_back(RealVector self, std::vector< double >::value_type const & x)"""
        return _fityk.RealVector_push_back(self, x)

    def front(self):
        r"""front(RealVector self) -> std::vector< double >::value_type const &"""
        return _fityk.RealVector_front(self)

    def back(self):
        r"""back(RealVector self) -> std::vector< double >::value_type const &"""
        return _fityk.RealVector_back(self)

    def assign(self, n, x):
        r"""assign(RealVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _fityk.RealVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(RealVector self, std::vector< double >::size_type new_size)
        resize(RealVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _fityk.RealVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(RealVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(RealVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _fityk.RealVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(RealVector self, std::vector< double >::size_type n)"""
        return _fityk.RealVector_reserve(self, n)

    def capacity(self):
        r"""capacity(RealVector self) -> std::vector< double >::size_type"""
        return _fityk.RealVector_capacity(self)
    __swig_destroy__ = _fityk.delete_RealVector

# Register RealVector in _fityk:
_fityk.RealVector_swigregister(RealVector)

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 _fityk.IntVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(IntVector self) -> bool"""
        return _fityk.IntVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(IntVector self) -> bool"""
        return _fityk.IntVector___bool__(self)

    def __len__(self):
        r"""__len__(IntVector self) -> std::vector< int >::size_type"""
        return _fityk.IntVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> IntVector"""
        return _fityk.IntVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)
        __setslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j, IntVector v)
        """
        return _fityk.IntVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _fityk.IntVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(IntVector self, std::vector< int >::difference_type i)
        __delitem__(IntVector self, PySliceObject * slice)
        """
        return _fityk.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(IntVector self, PySliceObject * slice) -> IntVector
        __getitem__(IntVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _fityk.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(IntVector self, PySliceObject * slice, IntVector v)
        __setitem__(IntVector self, PySliceObject * slice)
        __setitem__(IntVector self, std::vector< int >::difference_type i, std::vector< int >::value_type const & x)
        """
        return _fityk.IntVector___setitem__(self, *args)

    def pop(self):
        r"""pop(IntVector self) -> std::vector< int >::value_type"""
        return _fityk.IntVector_pop(self)

    def append(self, x):
        r"""append(IntVector self, std::vector< int >::value_type const & x)"""
        return _fityk.IntVector_append(self, x)

    def empty(self):
        r"""empty(IntVector self) -> bool"""
        return _fityk.IntVector_empty(self)

    def size(self):
        r"""size(IntVector self) -> std::vector< int >::size_type"""
        return _fityk.IntVector_size(self)

    def swap(self, v):
        r"""swap(IntVector self, IntVector v)"""
        return _fityk.IntVector_swap(self, v)

    def begin(self):
        r"""begin(IntVector self) -> std::vector< int >::iterator"""
        return _fityk.IntVector_begin(self)

    def end(self):
        r"""end(IntVector self) -> std::vector< int >::iterator"""
        return _fityk.IntVector_end(self)

    def rbegin(self):
        r"""rbegin(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _fityk.IntVector_rbegin(self)

    def rend(self):
        r"""rend(IntVector self) -> std::vector< int >::reverse_iterator"""
        return _fityk.IntVector_rend(self)

    def clear(self):
        r"""clear(IntVector self)"""
        return _fityk.IntVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(IntVector self) -> std::vector< int >::allocator_type"""
        return _fityk.IntVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(IntVector self)"""
        return _fityk.IntVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector self, std::vector< int >::iterator first, std::vector< int >::iterator last) -> std::vector< int >::iterator
        """
        return _fityk.IntVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(IntVector self) -> IntVector
        __init__(IntVector self, IntVector other) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size) -> IntVector
        __init__(IntVector self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _fityk.IntVector_swiginit(self, _fityk.new_IntVector(*args))

    def push_back(self, x):
        r"""push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _fityk.IntVector_push_back(self, x)

    def front(self):
        r"""front(IntVector self) -> std::vector< int >::value_type const &"""
        return _fityk.IntVector_front(self)

    def back(self):
        r"""back(IntVector self) -> std::vector< int >::value_type const &"""
        return _fityk.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)"""
        return _fityk.IntVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(IntVector self, std::vector< int >::size_type new_size)
        resize(IntVector self, std::vector< int >::size_type new_size, std::vector< int >::value_type const & x)
        """
        return _fityk.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
        insert(IntVector self, std::vector< int >::iterator pos, std::vector< int >::size_type n, std::vector< int >::value_type const & x)
        """
        return _fityk.IntVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(IntVector self, std::vector< int >::size_type n)"""
        return _fityk.IntVector_reserve(self, n)

    def capacity(self):
        r"""capacity(IntVector self) -> std::vector< int >::size_type"""
        return _fityk.IntVector_capacity(self)
    __swig_destroy__ = _fityk.delete_IntVector

# Register IntVector in _fityk:
_fityk.IntVector_swigregister(IntVector)

class VarVector(object):
    r"""Proxy of C++ std::vector< fityk::Var * > 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(VarVector self) -> SwigPyIterator"""
        return _fityk.VarVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(VarVector self) -> bool"""
        return _fityk.VarVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(VarVector self) -> bool"""
        return _fityk.VarVector___bool__(self)

    def __len__(self):
        r"""__len__(VarVector self) -> std::vector< fityk::Var * >::size_type"""
        return _fityk.VarVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(VarVector self, std::vector< fityk::Var * >::difference_type i, std::vector< fityk::Var * >::difference_type j) -> VarVector"""
        return _fityk.VarVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(VarVector self, std::vector< fityk::Var * >::difference_type i, std::vector< fityk::Var * >::difference_type j)
        __setslice__(VarVector self, std::vector< fityk::Var * >::difference_type i, std::vector< fityk::Var * >::difference_type j, VarVector v)
        """
        return _fityk.VarVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(VarVector self, std::vector< fityk::Var * >::difference_type i, std::vector< fityk::Var * >::difference_type j)"""
        return _fityk.VarVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(VarVector self, std::vector< fityk::Var * >::difference_type i)
        __delitem__(VarVector self, PySliceObject * slice)
        """
        return _fityk.VarVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(VarVector self, PySliceObject * slice) -> VarVector
        __getitem__(VarVector self, std::vector< fityk::Var * >::difference_type i) -> Var
        """
        return _fityk.VarVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(VarVector self, PySliceObject * slice, VarVector v)
        __setitem__(VarVector self, PySliceObject * slice)
        __setitem__(VarVector self, std::vector< fityk::Var * >::difference_type i, Var x)
        """
        return _fityk.VarVector___setitem__(self, *args)

    def pop(self):
        r"""pop(VarVector self) -> Var"""
        return _fityk.VarVector_pop(self)

    def append(self, x):
        r"""append(VarVector self, Var x)"""
        return _fityk.VarVector_append(self, x)

    def empty(self):
        r"""empty(VarVector self) -> bool"""
        return _fityk.VarVector_empty(self)

    def size(self):
        r"""size(VarVector self) -> std::vector< fityk::Var * >::size_type"""
        return _fityk.VarVector_size(self)

    def swap(self, v):
        r"""swap(VarVector self, VarVector v)"""
        return _fityk.VarVector_swap(self, v)

    def begin(self):
        r"""begin(VarVector self) -> std::vector< fityk::Var * >::iterator"""
        return _fityk.VarVector_begin(self)

    def end(self):
        r"""end(VarVector self) -> std::vector< fityk::Var * >::iterator"""
        return _fityk.VarVector_end(self)

    def rbegin(self):
        r"""rbegin(VarVector self) -> std::vector< fityk::Var * >::reverse_iterator"""
        return _fityk.VarVector_rbegin(self)

    def rend(self):
        r"""rend(VarVector self) -> std::vector< fityk::Var * >::reverse_iterator"""
        return _fityk.VarVector_rend(self)

    def clear(self):
        r"""clear(VarVector self)"""
        return _fityk.VarVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(VarVector self) -> std::vector< fityk::Var * >::allocator_type"""
        return _fityk.VarVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(VarVector self)"""
        return _fityk.VarVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(VarVector self, std::vector< fityk::Var * >::iterator pos) -> std::vector< fityk::Var * >::iterator
        erase(VarVector self, std::vector< fityk::Var * >::iterator first, std::vector< fityk::Var * >::iterator last) -> std::vector< fityk::Var * >::iterator
        """
        return _fityk.VarVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(VarVector self) -> VarVector
        __init__(VarVector self, VarVector other) -> VarVector
        __init__(VarVector self, std::vector< fityk::Var * >::size_type size) -> VarVector
        __init__(VarVector self, std::vector< fityk::Var * >::size_type size, Var value) -> VarVector
        """
        _fityk.VarVector_swiginit(self, _fityk.new_VarVector(*args))

    def push_back(self, x):
        r"""push_back(VarVector self, Var x)"""
        return _fityk.VarVector_push_back(self, x)

    def front(self):
        r"""front(VarVector self) -> Var"""
        return _fityk.VarVector_front(self)

    def back(self):
        r"""back(VarVector self) -> Var"""
        return _fityk.VarVector_back(self)

    def assign(self, n, x):
        r"""assign(VarVector self, std::vector< fityk::Var * >::size_type n, Var x)"""
        return _fityk.VarVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(VarVector self, std::vector< fityk::Var * >::size_type new_size)
        resize(VarVector self, std::vector< fityk::Var * >::size_type new_size, Var x)
        """
        return _fityk.VarVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(VarVector self, std::vector< fityk::Var * >::iterator pos, Var x) -> std::vector< fityk::Var * >::iterator
        insert(VarVector self, std::vector< fityk::Var * >::iterator pos, std::vector< fityk::Var * >::size_type n, Var x)
        """
        return _fityk.VarVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(VarVector self, std::vector< fityk::Var * >::size_type n)"""
        return _fityk.VarVector_reserve(self, n)

    def capacity(self):
        r"""capacity(VarVector self) -> std::vector< fityk::Var * >::size_type"""
        return _fityk.VarVector_capacity(self)
    __swig_destroy__ = _fityk.delete_VarVector

# Register VarVector in _fityk:
_fityk.VarVector_swigregister(VarVector)

class FuncVector(object):
    r"""Proxy of C++ std::vector< fityk::Func * > 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(FuncVector self) -> SwigPyIterator"""
        return _fityk.FuncVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(FuncVector self) -> bool"""
        return _fityk.FuncVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(FuncVector self) -> bool"""
        return _fityk.FuncVector___bool__(self)

    def __len__(self):
        r"""__len__(FuncVector self) -> std::vector< fityk::Func * >::size_type"""
        return _fityk.FuncVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(FuncVector self, std::vector< fityk::Func * >::difference_type i, std::vector< fityk::Func * >::difference_type j) -> FuncVector"""
        return _fityk.FuncVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(FuncVector self, std::vector< fityk::Func * >::difference_type i, std::vector< fityk::Func * >::difference_type j)
        __setslice__(FuncVector self, std::vector< fityk::Func * >::difference_type i, std::vector< fityk::Func * >::difference_type j, FuncVector v)
        """
        return _fityk.FuncVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(FuncVector self, std::vector< fityk::Func * >::difference_type i, std::vector< fityk::Func * >::difference_type j)"""
        return _fityk.FuncVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(FuncVector self, std::vector< fityk::Func * >::difference_type i)
        __delitem__(FuncVector self, PySliceObject * slice)
        """
        return _fityk.FuncVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(FuncVector self, PySliceObject * slice) -> FuncVector
        __getitem__(FuncVector self, std::vector< fityk::Func * >::difference_type i) -> Func
        """
        return _fityk.FuncVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(FuncVector self, PySliceObject * slice, FuncVector v)
        __setitem__(FuncVector self, PySliceObject * slice)
        __setitem__(FuncVector self, std::vector< fityk::Func * >::difference_type i, Func x)
        """
        return _fityk.FuncVector___setitem__(self, *args)

    def pop(self):
        r"""pop(FuncVector self) -> Func"""
        return _fityk.FuncVector_pop(self)

    def append(self, x):
        r"""append(FuncVector self, Func x)"""
        return _fityk.FuncVector_append(self, x)

    def empty(self):
        r"""empty(FuncVector self) -> bool"""
        return _fityk.FuncVector_empty(self)

    def size(self):
        r"""size(FuncVector self) -> std::vector< fityk::Func * >::size_type"""
        return _fityk.FuncVector_size(self)

    def swap(self, v):
        r"""swap(FuncVector self, FuncVector v)"""
        return _fityk.FuncVector_swap(self, v)

    def begin(self):
        r"""begin(FuncVector self) -> std::vector< fityk::Func * >::iterator"""
        return _fityk.FuncVector_begin(self)

    def end(self):
        r"""end(FuncVector self) -> std::vector< fityk::Func * >::iterator"""
        return _fityk.FuncVector_end(self)

    def rbegin(self):
        r"""rbegin(FuncVector self) -> std::vector< fityk::Func * >::reverse_iterator"""
        return _fityk.FuncVector_rbegin(self)

    def rend(self):
        r"""rend(FuncVector self) -> std::vector< fityk::Func * >::reverse_iterator"""
        return _fityk.FuncVector_rend(self)

    def clear(self):
        r"""clear(FuncVector self)"""
        return _fityk.FuncVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(FuncVector self) -> std::vector< fityk::Func * >::allocator_type"""
        return _fityk.FuncVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(FuncVector self)"""
        return _fityk.FuncVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(FuncVector self, std::vector< fityk::Func * >::iterator pos) -> std::vector< fityk::Func * >::iterator
        erase(FuncVector self, std::vector< fityk::Func * >::iterator first, std::vector< fityk::Func * >::iterator last) -> std::vector< fityk::Func * >::iterator
        """
        return _fityk.FuncVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(FuncVector self) -> FuncVector
        __init__(FuncVector self, FuncVector other) -> FuncVector
        __init__(FuncVector self, std::vector< fityk::Func * >::size_type size) -> FuncVector
        __init__(FuncVector self, std::vector< fityk::Func * >::size_type size, Func value) -> FuncVector
        """
        _fityk.FuncVector_swiginit(self, _fityk.new_FuncVector(*args))

    def push_back(self, x):
        r"""push_back(FuncVector self, Func x)"""
        return _fityk.FuncVector_push_back(self, x)

    def front(self):
        r"""front(FuncVector self) -> Func"""
        return _fityk.FuncVector_front(self)

    def back(self):
        r"""back(FuncVector self) -> Func"""
        return _fityk.FuncVector_back(self)

    def assign(self, n, x):
        r"""assign(FuncVector self, std::vector< fityk::Func * >::size_type n, Func x)"""
        return _fityk.FuncVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(FuncVector self, std::vector< fityk::Func * >::size_type new_size)
        resize(FuncVector self, std::vector< fityk::Func * >::size_type new_size, Func x)
        """
        return _fityk.FuncVector_resize(self, *args)

    def insert(self, *args):
        r"""
        insert(FuncVector self, std::vector< fityk::Func * >::iterator pos, Func x) -> std::vector< fityk::Func * >::iterator
        insert(FuncVector self, std::vector< fityk::Func * >::iterator pos, std::vector< fityk::Func * >::size_type n, Func x)
        """
        return _fityk.FuncVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(FuncVector self, std::vector< fityk::Func * >::size_type n)"""
        return _fityk.FuncVector_reserve(self, n)

    def capacity(self):
        r"""capacity(FuncVector self) -> std::vector< fityk::Func * >::size_type"""
        return _fityk.FuncVector_capacity(self)
    __swig_destroy__ = _fityk.delete_FuncVector

# Register FuncVector in _fityk:
_fityk.FuncVector_swigregister(FuncVector)

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 _fityk.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        r"""__nonzero__(StringVector self) -> bool"""
        return _fityk.StringVector___nonzero__(self)

    def __bool__(self):
        r"""__bool__(StringVector self) -> bool"""
        return _fityk.StringVector___bool__(self)

    def __len__(self):
        r"""__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return _fityk.StringVector___len__(self)

    def __getslice__(self, i, j):
        r"""__getslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVector"""
        return _fityk.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        r"""
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVector v)
        """
        return _fityk.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        r"""__delslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _fityk.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        r"""
        __delitem__(StringVector self, std::vector< std::string >::difference_type i)
        __delitem__(StringVector self, PySliceObject * slice)
        """
        return _fityk.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        r"""
        __getitem__(StringVector self, PySliceObject * slice) -> StringVector
        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _fityk.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        r"""
        __setitem__(StringVector self, PySliceObject * slice, StringVector v)
        __setitem__(StringVector self, PySliceObject * slice)
        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _fityk.StringVector___setitem__(self, *args)

    def pop(self):
        r"""pop(StringVector self) -> std::vector< std::string >::value_type"""
        return _fityk.StringVector_pop(self)

    def append(self, x):
        r"""append(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _fityk.StringVector_append(self, x)

    def empty(self):
        r"""empty(StringVector self) -> bool"""
        return _fityk.StringVector_empty(self)

    def size(self):
        r"""size(StringVector self) -> std::vector< std::string >::size_type"""
        return _fityk.StringVector_size(self)

    def swap(self, v):
        r"""swap(StringVector self, StringVector v)"""
        return _fityk.StringVector_swap(self, v)

    def begin(self):
        r"""begin(StringVector self) -> std::vector< std::string >::iterator"""
        return _fityk.StringVector_begin(self)

    def end(self):
        r"""end(StringVector self) -> std::vector< std::string >::iterator"""
        return _fityk.StringVector_end(self)

    def rbegin(self):
        r"""rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _fityk.StringVector_rbegin(self)

    def rend(self):
        r"""rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _fityk.StringVector_rend(self)

    def clear(self):
        r"""clear(StringVector self)"""
        return _fityk.StringVector_clear(self)

    def get_allocator(self):
        r"""get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return _fityk.StringVector_get_allocator(self)

    def pop_back(self):
        r"""pop_back(StringVector self)"""
        return _fityk.StringVector_pop_back(self)

    def erase(self, *args):
        r"""
        erase(StringVector self, std::vector< std::string >::iterator 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
        """
        return _fityk.StringVector_erase(self, *args)

    def __init__(self, *args):
        r"""
        __init__(StringVector self) -> StringVector
        __init__(StringVector self, StringVector other) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size) -> StringVector
        __init__(StringVector self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        _fityk.StringVector_swiginit(self, _fityk.new_StringVector(*args))

    def push_back(self, x):
        r"""push_back(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _fityk.StringVector_push_back(self, x)

    def front(self):
        r"""front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _fityk.StringVector_front(self)

    def back(self):
        r"""back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _fityk.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)"""
        return _fityk.StringVector_assign(self, n, x)

    def resize(self, *args):
        r"""
        resize(StringVector self, std::vector< std::string >::size_type new_size)
        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _fityk.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
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _fityk.StringVector_insert(self, *args)

    def reserve(self, n):
        r"""reserve(StringVector self, std::vector< std::string >::size_type n)"""
        return _fityk.StringVector_reserve(self, n)

    def capacity(self):
        r"""capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _fityk.StringVector_capacity(self)
    __swig_destroy__ = _fityk.delete_StringVector

# Register StringVector in _fityk:
_fityk.StringVector_swigregister(StringVector)

class UiApi(object):
    r"""Proxy of C++ fityk::UiApi 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
    kNormal = _fityk.UiApi_kNormal
    
    kWarning = _fityk.UiApi_kWarning
    
    kQuoted = _fityk.UiApi_kQuoted
    
    kInput = _fityk.UiApi_kInput
    
    kRepaint = _fityk.UiApi_kRepaint
    
    kRepaintImmediately = _fityk.UiApi_kRepaintImmediately
    
    kStatusOk = _fityk.UiApi_kStatusOk
    
    kStatusExecuteError = _fityk.UiApi_kStatusExecuteError
    
    kStatusSyntaxError = _fityk.UiApi_kStatusSyntaxError
    
    __swig_destroy__ = _fityk.delete_UiApi

    def exec_and_log(self, c):
        r"""exec_and_log(UiApi self, std::string const & c) -> fityk::UiApi::Status"""
        return _fityk.UiApi_exec_and_log(self, c)

    def exec_fityk_script(self, filename):
        r"""exec_fityk_script(UiApi self, std::string const & filename)"""
        return _fityk.UiApi_exec_fityk_script(self, filename)

    def connect_draw_plot(self, func):
        r"""connect_draw_plot(UiApi self, fityk::UiApi::t_draw_plot_callback * func) -> fityk::UiApi::t_draw_plot_callback *"""
        return _fityk.UiApi_connect_draw_plot(self, func)

    def connect_show_message(self, func):
        r"""connect_show_message(UiApi self, fityk::UiApi::t_show_message_callback * func) -> fityk::UiApi::t_show_message_callback *"""
        return _fityk.UiApi_connect_show_message(self, func)

    def connect_exec_command(self, func):
        r"""connect_exec_command(UiApi self, fityk::UiApi::t_exec_command_callback * func) -> fityk::UiApi::t_exec_command_callback *"""
        return _fityk.UiApi_connect_exec_command(self, func)

    def connect_hint_ui(self, func):
        r"""connect_hint_ui(UiApi self, fityk::UiApi::t_hint_ui_callback * func) -> fityk::UiApi::t_hint_ui_callback *"""
        return _fityk.UiApi_connect_hint_ui(self, func)

    def connect_user_input(self, func):
        r"""connect_user_input(UiApi self, fityk::UiApi::t_user_input_callback * func) -> fityk::UiApi::t_user_input_callback *"""
        return _fityk.UiApi_connect_user_input(self, func)

    def connect_ui_state(self, func):
        r"""connect_ui_state(UiApi self, fityk::UiApi::t_ui_state_callback * func) -> fityk::UiApi::t_ui_state_callback *"""
        return _fityk.UiApi_connect_ui_state(self, func)

    def connect_show_message_py(self, pyfunc):
        r"""connect_show_message_py(UiApi self, PyObject * pyfunc)"""
        return _fityk.UiApi_connect_show_message_py(self, pyfunc)

    def connect_draw_plot_py(self, pyfunc):
        r"""connect_draw_plot_py(UiApi self, PyObject * pyfunc)"""
        return _fityk.UiApi_connect_draw_plot_py(self, pyfunc)

# Register UiApi in _fityk:
_fityk.UiApi_swigregister(UiApi)


def complete_fityk_line(F, line_buffer, start, end, text):
    r"""complete_fityk_line(Fityk * F, char const * line_buffer, int start, int end, char const * text) -> StringVector"""
    return _fityk.complete_fityk_line(F, line_buffer, start, end, text)

def startup_commands_filename():
    r"""startup_commands_filename() -> char const *"""
    return _fityk.startup_commands_filename()

def config_dirname():
    r"""config_dirname() -> char const *"""
    return _fityk.config_dirname()

def interrupt_computations():
    r"""interrupt_computations()"""
    return _fityk.interrupt_computations()

def interrupt_computations_on_sigint():
    r"""interrupt_computations_on_sigint()"""
    return _fityk.interrupt_computations_on_sigint()
USE_LONG_DOUBLE = _fityk.USE_LONG_DOUBLE

REALT_LENGTH_MOD = _fityk.REALT_LENGTH_MOD

class ExecuteError(Exception):
    r"""Proxy of C++ fityk::ExecuteError 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, msg):
        r"""__init__(ExecuteError self, std::string const & msg) -> ExecuteError"""
        _fityk.ExecuteError_swiginit(self, _fityk.new_ExecuteError(msg))

    def __str__(self):
        r"""__str__(ExecuteError self) -> char const *"""
        return _fityk.ExecuteError___str__(self)
    __swig_destroy__ = _fityk.delete_ExecuteError

# Register ExecuteError in _fityk:
_fityk.ExecuteError_swigregister(ExecuteError)

class SyntaxError(Exception):
    r"""Proxy of C++ fityk::SyntaxError 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, *args):
        r"""__init__(SyntaxError self, std::string const & msg="") -> SyntaxError"""
        _fityk.SyntaxError_swiginit(self, _fityk.new_SyntaxError(*args))

    def __str__(self):
        r"""__str__(SyntaxError self) -> char const *"""
        return _fityk.SyntaxError___str__(self)
    __swig_destroy__ = _fityk.delete_SyntaxError

# Register SyntaxError in _fityk:
_fityk.SyntaxError_swigregister(SyntaxError)

class ExitRequestedException(Exception):
    r"""Proxy of C++ fityk::ExitRequestedException 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"""__init__(ExitRequestedException self) -> ExitRequestedException"""
        _fityk.ExitRequestedException_swiginit(self, _fityk.new_ExitRequestedException())
    __swig_destroy__ = _fityk.delete_ExitRequestedException

# Register ExitRequestedException in _fityk:
_fityk.ExitRequestedException_swigregister(ExitRequestedException)

class RealRange(object):
    r"""Proxy of C++ fityk::RealRange class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    lo = property(_fityk.RealRange_lo_get, _fityk.RealRange_lo_set, doc=r"""lo : double""")
    hi = property(_fityk.RealRange_hi_get, _fityk.RealRange_hi_set, doc=r"""hi : double""")

    def __init__(self, *args):
        r"""
        __init__(RealRange self) -> RealRange
        __init__(RealRange self, double low, double high) -> RealRange
        """
        _fityk.RealRange_swiginit(self, _fityk.new_RealRange(*args))

    def lo_inf(self):
        r"""lo_inf(RealRange self) -> bool"""
        return _fityk.RealRange_lo_inf(self)

    def hi_inf(self):
        r"""hi_inf(RealRange self) -> bool"""
        return _fityk.RealRange_hi_inf(self)

    def str(self):
        r"""str(RealRange self) -> std::string"""
        return _fityk.RealRange_str(self)
    __swig_destroy__ = _fityk.delete_RealRange

# Register RealRange in _fityk:
_fityk.RealRange_swigregister(RealRange)

class Var(object):
    r"""Proxy of C++ fityk::Var 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")
    __repr__ = _swig_repr
    name = property(_fityk.Var_name_get, doc=r"""name : q(const).std::string""")
    domain = property(_fityk.Var_domain_get, _fityk.Var_domain_set, doc=r"""domain : fityk::RealRange""")

    def value(self):
        r"""value(Var self) -> realt"""
        return _fityk.Var_value(self)

    def gpos(self):
        r"""gpos(Var self) -> int"""
        return _fityk.Var_gpos(self)

    def is_simple(self):
        r"""is_simple(Var self) -> bool"""
        return _fityk.Var_is_simple(self)

    def __str__(self):
        r"""__str__(Var self) -> std::string"""
        return _fityk.Var___str__(self)

# Register Var in _fityk:
_fityk.Var_swigregister(Var)

class Func(object):
    r"""Proxy of C++ fityk::Func 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
    name = property(_fityk.Func_name_get, doc=r"""name : q(const).std::string""")
    __swig_destroy__ = _fityk.delete_Func

    def get_template_name(self):
        r"""get_template_name(Func self) -> std::string const &"""
        return _fityk.Func_get_template_name(self)

    def get_param(self, n):
        r"""get_param(Func self, int n) -> std::string"""
        return _fityk.Func_get_param(self, n)

    def var_name(self, param):
        r"""var_name(Func self, std::string const & param) -> std::string const &"""
        return _fityk.Func_var_name(self, param)

    def get_param_value(self, param):
        r"""get_param_value(Func self, std::string const & param) -> realt"""
        return _fityk.Func_get_param_value(self, param)

    def value_at(self, x):
        r"""value_at(Func self, realt x) -> realt"""
        return _fityk.Func_value_at(self, x)

    def __str__(self):
        r"""__str__(Func self) -> std::string"""
        return _fityk.Func___str__(self)

# Register Func in _fityk:
_fityk.Func_swigregister(Func)

ALL_DATASETS = _fityk.ALL_DATASETS

DEFAULT_DATASET = _fityk.DEFAULT_DATASET

class Point(object):
    r"""Proxy of C++ fityk::Point class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    x = property(_fityk.Point_x_get, _fityk.Point_x_set, doc=r"""x : realt""")
    y = property(_fityk.Point_y_get, _fityk.Point_y_set, doc=r"""y : realt""")
    sigma = property(_fityk.Point_sigma_get, _fityk.Point_sigma_set, doc=r"""sigma : realt""")
    is_active = property(_fityk.Point_is_active_get, _fityk.Point_is_active_set, doc=r"""is_active : bool""")

    def __init__(self, *args):
        r"""
        __init__(Point self) -> Point
        __init__(Point self, realt x_, realt y_) -> Point
        __init__(Point self, realt x_, realt y_, realt sigma_) -> Point
        """
        _fityk.Point_swiginit(self, _fityk.new_Point(*args))

    def str(self):
        r"""str(Point self) -> std::string"""
        return _fityk.Point_str(self)

    def __lt__(self, q):
        r"""__lt__(Point self, Point q) -> bool"""
        return _fityk.Point___lt__(self, q)

    def __str__(self):
        r"""__str__(Point self) -> std::string"""
        return _fityk.Point___str__(self)
    __swig_destroy__ = _fityk.delete_Point

# Register Point in _fityk:
_fityk.Point_swigregister(Point)

class LoadSpec(object):
    r"""Proxy of C++ fityk::LoadSpec class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    NN = _fityk.LoadSpec_NN
    
    path = property(_fityk.LoadSpec_path_get, _fityk.LoadSpec_path_set, doc=r"""path : std::string""")
    blocks = property(_fityk.LoadSpec_blocks_get, _fityk.LoadSpec_blocks_set, doc=r"""blocks : std::vector<(int,std::allocator<(int)>)>""")
    x_col = property(_fityk.LoadSpec_x_col_get, _fityk.LoadSpec_x_col_set, doc=r"""x_col : int""")
    y_col = property(_fityk.LoadSpec_y_col_get, _fityk.LoadSpec_y_col_set, doc=r"""y_col : int""")
    sig_col = property(_fityk.LoadSpec_sig_col_get, _fityk.LoadSpec_sig_col_set, doc=r"""sig_col : int""")
    format = property(_fityk.LoadSpec_format_get, _fityk.LoadSpec_format_set, doc=r"""format : std::string""")
    options = property(_fityk.LoadSpec_options_get, _fityk.LoadSpec_options_set, doc=r"""options : std::string""")

    def __init__(self, *args):
        r"""
        __init__(LoadSpec self) -> LoadSpec
        __init__(LoadSpec self, std::string const & p) -> LoadSpec
        """
        _fityk.LoadSpec_swiginit(self, _fityk.new_LoadSpec(*args))
    __swig_destroy__ = _fityk.delete_LoadSpec

# Register LoadSpec in _fityk:
_fityk.LoadSpec_swigregister(LoadSpec)

class Fityk(object):
    r"""Proxy of C++ fityk::Fityk 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, *args):
        r"""
        __init__(Fityk self) -> Fityk
        __init__(Fityk self, fityk::Full * F) -> Fityk
        """
        _fityk.Fityk_swiginit(self, _fityk.new_Fityk(*args))
    __swig_destroy__ = _fityk.delete_Fityk

    def execute(self, s):
        r"""execute(Fityk self, std::string const & s)"""
        return _fityk.Fityk_execute(self, s)

    def load(self, *args):
        r"""
        load(Fityk self, LoadSpec spec, int dataset=DEFAULT_DATASET)
        load(Fityk self, std::string const & path, int dataset=DEFAULT_DATASET)
        """
        return _fityk.Fityk_load(self, *args)

    def load_data(self, *args):
        r"""load_data(Fityk self, int dataset, RealVector x, RealVector y, RealVector sigma, std::string const & title="")"""
        return _fityk.Fityk_load_data(self, *args)

    def add_point(self, *args):
        r"""add_point(Fityk self, realt x, realt y, realt sigma, int dataset=DEFAULT_DATASET)"""
        return _fityk.Fityk_add_point(self, *args)

    def set_throws(self, state):
        r"""set_throws(Fityk self, bool state)"""
        return _fityk.Fityk_set_throws(self, state)

    def get_throws(self):
        r"""get_throws(Fityk self) -> bool"""
        return _fityk.Fityk_get_throws(self)

    def last_error(self):
        r"""last_error(Fityk self) -> std::string const &"""
        return _fityk.Fityk_last_error(self)

    def clear_last_error(self):
        r"""clear_last_error(Fityk self)"""
        return _fityk.Fityk_clear_last_error(self)

    def set_option_as_string(self, opt, val):
        r"""set_option_as_string(Fityk self, std::string const & opt, std::string const & val)"""
        return _fityk.Fityk_set_option_as_string(self, opt, val)

    def set_option_as_number(self, opt, val):
        r"""set_option_as_number(Fityk self, std::string const & opt, double val)"""
        return _fityk.Fityk_set_option_as_number(self, opt, val)

    def get_option_as_string(self, opt):
        r"""get_option_as_string(Fityk self, std::string const & opt) -> std::string"""
        return _fityk.Fityk_get_option_as_string(self, opt)

    def get_option_as_number(self, opt):
        r"""get_option_as_number(Fityk self, std::string const & opt) -> double"""
        return _fityk.Fityk_get_option_as_number(self, opt)

    def redir_messages(self, stream):
        r"""redir_messages(Fityk self, std::FILE * stream)"""
        return _fityk.Fityk_redir_messages(self, stream)

    def out(self, s):
        r"""out(Fityk self, std::string const & s)"""
        return _fityk.Fityk_out(self, s)

    def input(self, prompt):
        r"""input(Fityk self, std::string const & prompt) -> std::string"""
        return _fityk.Fityk_input(self, prompt)

    def get_info(self, *args):
        r"""get_info(Fityk self, std::string const & s, int dataset=DEFAULT_DATASET) -> std::string"""
        return _fityk.Fityk_get_info(self, *args)

    def calculate_expr(self, *args):
        r"""calculate_expr(Fityk self, std::string const & s, int dataset=DEFAULT_DATASET) -> realt"""
        return _fityk.Fityk_calculate_expr(self, *args)

    def get_dataset_count(self):
        r"""get_dataset_count(Fityk self) -> int"""
        return _fityk.Fityk_get_dataset_count(self)

    def get_default_dataset(self):
        r"""get_default_dataset(Fityk self) -> int"""
        return _fityk.Fityk_get_default_dataset(self)

    def get_data(self, *args):
        r"""get_data(Fityk self, int dataset=DEFAULT_DATASET) -> PointVector"""
        return _fityk.Fityk_get_data(self, *args)

    def get_parameter_count(self):
        r"""get_parameter_count(Fityk self) -> int"""
        return _fityk.Fityk_get_parameter_count(self)

    def all_parameters(self):
        r"""all_parameters(Fityk self) -> RealVector"""
        return _fityk.Fityk_all_parameters(self)

    def all_variables(self):
        r"""all_variables(Fityk self) -> VarVector"""
        return _fityk.Fityk_all_variables(self)

    def get_variable(self, name):
        r"""get_variable(Fityk self, std::string const & name) -> Var"""
        return _fityk.Fityk_get_variable(self, name)

    def all_functions(self):
        r"""all_functions(Fityk self) -> FuncVector"""
        return _fityk.Fityk_all_functions(self)

    def get_function(self, name):
        r"""get_function(Fityk self, std::string const & name) -> Func"""
        return _fityk.Fityk_get_function(self, name)

    def get_components(self, *args):
        r"""get_components(Fityk self, int dataset=DEFAULT_DATASET, char fz='F') -> FuncVector"""
        return _fityk.Fityk_get_components(self, *args)

    def get_model_value(self, *args):
        r"""get_model_value(Fityk self, realt x, int dataset=DEFAULT_DATASET) -> realt"""
        return _fityk.Fityk_get_model_value(self, *args)

    def get_model_vector(self, *args):
        r"""get_model_vector(Fityk self, RealVector x, int dataset=DEFAULT_DATASET) -> RealVector"""
        return _fityk.Fityk_get_model_vector(self, *args)

    def get_view_boundary(self, side):
        r"""get_view_boundary(Fityk self, char side) -> double"""
        return _fityk.Fityk_get_view_boundary(self, side)

    def get_wssr(self, *args):
        r"""get_wssr(Fityk self, int dataset=ALL_DATASETS) -> realt"""
        return _fityk.Fityk_get_wssr(self, *args)

    def get_ssr(self, *args):
        r"""get_ssr(Fityk self, int dataset=ALL_DATASETS) -> realt"""
        return _fityk.Fityk_get_ssr(self, *args)

    def get_rsquared(self, *args):
        r"""get_rsquared(Fityk self, int dataset=ALL_DATASETS) -> realt"""
        return _fityk.Fityk_get_rsquared(self, *args)

    def get_dof(self, *args):
        r"""get_dof(Fityk self, int dataset=ALL_DATASETS) -> int"""
        return _fityk.Fityk_get_dof(self, *args)

    def get_covariance_matrix(self, *args):
        r"""get_covariance_matrix(Fityk self, int dataset=ALL_DATASETS) -> std::vector< std::vector< realt,std::allocator< realt > >,std::allocator< std::vector< realt,std::allocator< realt > > > >"""
        return _fityk.Fityk_get_covariance_matrix(self, *args)

    def get_ui_api(self):
        r"""get_ui_api(Fityk self) -> UiApi"""
        return _fityk.Fityk_get_ui_api(self)

    def process_cmd_line_arg(self, arg):
        r"""process_cmd_line_arg(Fityk self, std::string const & arg)"""
        return _fityk.Fityk_process_cmd_line_arg(self, arg)

    def priv(self):
        r"""priv(Fityk self) -> fityk::Full *"""
        return _fityk.Fityk_priv(self)

# Register Fityk in _fityk:
_fityk.Fityk_swigregister(Fityk)



