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




"""Python Orthogonal Array interface"""


from sys import version_info
if version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_oalib', [dirname(__file__)])
        except ImportError:
            import _oalib
            return _oalib
        if fp is not None:
            try:
                _mod = imp.load_module('_oalib', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _oalib = swig_import_helper()
    del swig_import_helper
else:
    import _oalib
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        object.__setattr__(self, name, value)
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0



def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class SwigPyIterator(object):
    thisown = _swig_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__ = _oalib.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _oalib.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _oalib.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _oalib.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _oalib.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _oalib.SwigPyIterator_equal(self, x)

    def copy(self):
        return _oalib.SwigPyIterator_copy(self)

    def next(self):
        return _oalib.SwigPyIterator_next(self)

    def __next__(self):
        return _oalib.SwigPyIterator___next__(self)

    def previous(self):
        return _oalib.SwigPyIterator_previous(self)

    def advance(self, n):
        return _oalib.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _oalib.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _oalib.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _oalib.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _oalib.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _oalib.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _oalib.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _oalib.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


import sys
import numpy as np

def reduceGraphNauty(G, colors, verbose=1):
  """ Reduce vertex transformation reducing array to normal form

  The reduction is calculated using `Nauty <http://pallini.di.uniroma1.it/>`_

  Arguments
  ---------
      G : Numpy array
	the graph in incidence matrix form
      colors : list
	an optional vertex coloring
  """

  al=array_link()
  al.setarray(G)
  if colors is None:
    colors = [0] * G.shape[0]
  v = _oalib.reduceNauty ( al, colors, verbose )
  return v

def transformGraphMatrix(G, tr, verbose=1):
    """ Apply a vertex permutation to a graph 

    Arguments
    ---------
      G : Numpy array
	the graph in incidence matrix form
      tr : list 
	the vertex transformation as a list

    Returns
    -------
      The transformed graph

    """
    al=array_link()
    al.setarray(G)
    alt = _oalib.transformGraph(al, tr, verbose)  
    return np.array(alt)


class arraylist_t(object):
    """Proxy of C++ std::deque<(array_link)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def iterator(self):
        """iterator(arraylist_t self) -> SwigPyIterator"""
        return _oalib.arraylist_t_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(arraylist_t self) -> bool"""
        return _oalib.arraylist_t___nonzero__(self)


    def __bool__(self):
        """__bool__(arraylist_t self) -> bool"""
        return _oalib.arraylist_t___bool__(self)


    def __len__(self):
        """__len__(arraylist_t self) -> std::deque< array_link >::size_type"""
        return _oalib.arraylist_t___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(arraylist_t self, std::deque< array_link >::difference_type i, std::deque< array_link >::difference_type j) -> arraylist_t"""
        return _oalib.arraylist_t___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(arraylist_t self, std::deque< array_link >::difference_type i, std::deque< array_link >::difference_type j)
        __setslice__(arraylist_t self, std::deque< array_link >::difference_type i, std::deque< array_link >::difference_type j, arraylist_t v)
        """
        return _oalib.arraylist_t___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(arraylist_t self, std::deque< array_link >::difference_type i, std::deque< array_link >::difference_type j)"""
        return _oalib.arraylist_t___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(arraylist_t self, std::deque< array_link >::difference_type i)
        __delitem__(arraylist_t self, PySliceObject * slice)
        """
        return _oalib.arraylist_t___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(arraylist_t self, PySliceObject * slice) -> arraylist_t
        __getitem__(arraylist_t self, std::deque< array_link >::difference_type i) -> array_link
        """
        return _oalib.arraylist_t___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(arraylist_t self, PySliceObject * slice, arraylist_t v)
        __setitem__(arraylist_t self, PySliceObject * slice)
        __setitem__(arraylist_t self, std::deque< array_link >::difference_type i, array_link x)
        """
        return _oalib.arraylist_t___setitem__(self, *args)


    def pop(self):
        """pop(arraylist_t self) -> array_link"""
        return _oalib.arraylist_t_pop(self)


    def append(self, x):
        """append(arraylist_t self, array_link x)"""
        return _oalib.arraylist_t_append(self, x)


    def empty(self):
        """empty(arraylist_t self) -> bool"""
        return _oalib.arraylist_t_empty(self)


    def size(self):
        """size(arraylist_t self) -> std::deque< array_link >::size_type"""
        return _oalib.arraylist_t_size(self)


    def swap(self, v):
        """swap(arraylist_t self, arraylist_t v)"""
        return _oalib.arraylist_t_swap(self, v)


    def begin(self):
        """begin(arraylist_t self) -> std::deque< array_link >::iterator"""
        return _oalib.arraylist_t_begin(self)


    def end(self):
        """end(arraylist_t self) -> std::deque< array_link >::iterator"""
        return _oalib.arraylist_t_end(self)


    def rbegin(self):
        """rbegin(arraylist_t self) -> std::deque< array_link >::reverse_iterator"""
        return _oalib.arraylist_t_rbegin(self)


    def rend(self):
        """rend(arraylist_t self) -> std::deque< array_link >::reverse_iterator"""
        return _oalib.arraylist_t_rend(self)


    def clear(self):
        """clear(arraylist_t self)"""
        return _oalib.arraylist_t_clear(self)


    def get_allocator(self):
        """get_allocator(arraylist_t self) -> std::deque< array_link >::allocator_type"""
        return _oalib.arraylist_t_get_allocator(self)


    def pop_back(self):
        """pop_back(arraylist_t self)"""
        return _oalib.arraylist_t_pop_back(self)


    def erase(self, *args):
        """
        erase(arraylist_t self, std::deque< array_link >::iterator pos) -> std::deque< array_link >::iterator
        erase(arraylist_t self, std::deque< array_link >::iterator first, std::deque< array_link >::iterator last) -> std::deque< array_link >::iterator
        """
        return _oalib.arraylist_t_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::deque<(array_link)> self) -> arraylist_t
        __init__(std::deque<(array_link)> self, arraylist_t arg2) -> arraylist_t
        __init__(std::deque<(array_link)> self, std::deque< array_link >::size_type size) -> arraylist_t
        __init__(std::deque<(array_link)> self, std::deque< array_link >::size_type size, array_link value) -> arraylist_t
        """
        this = _oalib.new_arraylist_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(arraylist_t self, array_link x)"""
        return _oalib.arraylist_t_push_back(self, x)


    def front(self):
        """front(arraylist_t self) -> array_link"""
        return _oalib.arraylist_t_front(self)


    def back(self):
        """back(arraylist_t self) -> array_link"""
        return _oalib.arraylist_t_back(self)


    def assign(self, n, x):
        """assign(arraylist_t self, std::deque< array_link >::size_type n, array_link x)"""
        return _oalib.arraylist_t_assign(self, n, x)


    def resize(self, *args):
        """
        resize(arraylist_t self, std::deque< array_link >::size_type new_size)
        resize(arraylist_t self, std::deque< array_link >::size_type new_size, array_link x)
        """
        return _oalib.arraylist_t_resize(self, *args)


    def insert(self, *args):
        """
        insert(arraylist_t self, std::deque< array_link >::iterator pos, array_link x) -> std::deque< array_link >::iterator
        insert(arraylist_t self, std::deque< array_link >::iterator pos, std::deque< array_link >::size_type n, array_link x)
        """
        return _oalib.arraylist_t_insert(self, *args)


    def pop_front(self):
        """pop_front(arraylist_t self)"""
        return _oalib.arraylist_t_pop_front(self)


    def push_front(self, x):
        """push_front(arraylist_t self, array_link x)"""
        return _oalib.arraylist_t_push_front(self, x)


    def __repr__(self):
        """__repr__(arraylist_t self) -> std::string"""
        return _oalib.arraylist_t___repr__(self)

    __swig_destroy__ = _oalib.delete_arraylist_t
    __del__ = lambda self: None
arraylist_t_swigregister = _oalib.arraylist_t_swigregister
arraylist_t_swigregister(arraylist_t)

class jstructArray(object):
    """Proxy of C++ std::vector<(jstruct_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(jstructArray self) -> SwigPyIterator"""
        return _oalib.jstructArray_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(jstructArray self) -> bool"""
        return _oalib.jstructArray___nonzero__(self)


    def __bool__(self):
        """__bool__(jstructArray self) -> bool"""
        return _oalib.jstructArray___bool__(self)


    def __len__(self):
        """__len__(jstructArray self) -> std::vector< jstruct_t >::size_type"""
        return _oalib.jstructArray___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(jstructArray self, std::vector< jstruct_t >::difference_type i, std::vector< jstruct_t >::difference_type j) -> jstructArray"""
        return _oalib.jstructArray___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(jstructArray self, std::vector< jstruct_t >::difference_type i, std::vector< jstruct_t >::difference_type j)
        __setslice__(jstructArray self, std::vector< jstruct_t >::difference_type i, std::vector< jstruct_t >::difference_type j, jstructArray v)
        """
        return _oalib.jstructArray___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(jstructArray self, std::vector< jstruct_t >::difference_type i, std::vector< jstruct_t >::difference_type j)"""
        return _oalib.jstructArray___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(jstructArray self, std::vector< jstruct_t >::difference_type i)
        __delitem__(jstructArray self, PySliceObject * slice)
        """
        return _oalib.jstructArray___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(jstructArray self, PySliceObject * slice) -> jstructArray
        __getitem__(jstructArray self, std::vector< jstruct_t >::difference_type i) -> jstruct_t
        """
        return _oalib.jstructArray___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(jstructArray self, PySliceObject * slice, jstructArray v)
        __setitem__(jstructArray self, PySliceObject * slice)
        __setitem__(jstructArray self, std::vector< jstruct_t >::difference_type i, jstruct_t x)
        """
        return _oalib.jstructArray___setitem__(self, *args)


    def pop(self):
        """pop(jstructArray self) -> jstruct_t"""
        return _oalib.jstructArray_pop(self)


    def append(self, x):
        """append(jstructArray self, jstruct_t x)"""
        return _oalib.jstructArray_append(self, x)


    def empty(self):
        """empty(jstructArray self) -> bool"""
        return _oalib.jstructArray_empty(self)


    def size(self):
        """size(jstructArray self) -> std::vector< jstruct_t >::size_type"""
        return _oalib.jstructArray_size(self)


    def swap(self, v):
        """swap(jstructArray self, jstructArray v)"""
        return _oalib.jstructArray_swap(self, v)


    def begin(self):
        """begin(jstructArray self) -> std::vector< jstruct_t >::iterator"""
        return _oalib.jstructArray_begin(self)


    def end(self):
        """end(jstructArray self) -> std::vector< jstruct_t >::iterator"""
        return _oalib.jstructArray_end(self)


    def rbegin(self):
        """rbegin(jstructArray self) -> std::vector< jstruct_t >::reverse_iterator"""
        return _oalib.jstructArray_rbegin(self)


    def rend(self):
        """rend(jstructArray self) -> std::vector< jstruct_t >::reverse_iterator"""
        return _oalib.jstructArray_rend(self)


    def clear(self):
        """clear(jstructArray self)"""
        return _oalib.jstructArray_clear(self)


    def get_allocator(self):
        """get_allocator(jstructArray self) -> std::vector< jstruct_t >::allocator_type"""
        return _oalib.jstructArray_get_allocator(self)


    def pop_back(self):
        """pop_back(jstructArray self)"""
        return _oalib.jstructArray_pop_back(self)


    def erase(self, *args):
        """
        erase(jstructArray self, std::vector< jstruct_t >::iterator pos) -> std::vector< jstruct_t >::iterator
        erase(jstructArray self, std::vector< jstruct_t >::iterator first, std::vector< jstruct_t >::iterator last) -> std::vector< jstruct_t >::iterator
        """
        return _oalib.jstructArray_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(jstruct_t)> self) -> jstructArray
        __init__(std::vector<(jstruct_t)> self, jstructArray arg2) -> jstructArray
        __init__(std::vector<(jstruct_t)> self, std::vector< jstruct_t >::size_type size) -> jstructArray
        __init__(std::vector<(jstruct_t)> self, std::vector< jstruct_t >::size_type size, jstruct_t value) -> jstructArray
        """
        this = _oalib.new_jstructArray(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(jstructArray self, jstruct_t x)"""
        return _oalib.jstructArray_push_back(self, x)


    def front(self):
        """front(jstructArray self) -> jstruct_t"""
        return _oalib.jstructArray_front(self)


    def back(self):
        """back(jstructArray self) -> jstruct_t"""
        return _oalib.jstructArray_back(self)


    def assign(self, n, x):
        """assign(jstructArray self, std::vector< jstruct_t >::size_type n, jstruct_t x)"""
        return _oalib.jstructArray_assign(self, n, x)


    def resize(self, *args):
        """
        resize(jstructArray self, std::vector< jstruct_t >::size_type new_size)
        resize(jstructArray self, std::vector< jstruct_t >::size_type new_size, jstruct_t x)
        """
        return _oalib.jstructArray_resize(self, *args)


    def insert(self, *args):
        """
        insert(jstructArray self, std::vector< jstruct_t >::iterator pos, jstruct_t x) -> std::vector< jstruct_t >::iterator
        insert(jstructArray self, std::vector< jstruct_t >::iterator pos, std::vector< jstruct_t >::size_type n, jstruct_t x)
        """
        return _oalib.jstructArray_insert(self, *args)


    def reserve(self, n):
        """reserve(jstructArray self, std::vector< jstruct_t >::size_type n)"""
        return _oalib.jstructArray_reserve(self, n)


    def capacity(self):
        """capacity(jstructArray self) -> std::vector< jstruct_t >::size_type"""
        return _oalib.jstructArray_capacity(self)

    __swig_destroy__ = _oalib.delete_jstructArray
    __del__ = lambda self: None
jstructArray_swigregister = _oalib.jstructArray_swigregister
jstructArray_swigregister(jstructArray)

class uint8Vector(object):
    """Proxy of C++ std::vector<(unsigned char)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(uint8Vector self) -> SwigPyIterator"""
        return _oalib.uint8Vector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(uint8Vector self) -> bool"""
        return _oalib.uint8Vector___nonzero__(self)


    def __bool__(self):
        """__bool__(uint8Vector self) -> bool"""
        return _oalib.uint8Vector___bool__(self)


    def __len__(self):
        """__len__(uint8Vector self) -> std::vector< unsigned char >::size_type"""
        return _oalib.uint8Vector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(uint8Vector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> uint8Vector"""
        return _oalib.uint8Vector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(uint8Vector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        __setslice__(uint8Vector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, uint8Vector v)
        """
        return _oalib.uint8Vector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(uint8Vector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _oalib.uint8Vector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(uint8Vector self, std::vector< unsigned char >::difference_type i)
        __delitem__(uint8Vector self, PySliceObject * slice)
        """
        return _oalib.uint8Vector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(uint8Vector self, PySliceObject * slice) -> uint8Vector
        __getitem__(uint8Vector self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _oalib.uint8Vector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(uint8Vector self, PySliceObject * slice, uint8Vector v)
        __setitem__(uint8Vector self, PySliceObject * slice)
        __setitem__(uint8Vector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _oalib.uint8Vector___setitem__(self, *args)


    def pop(self):
        """pop(uint8Vector self) -> std::vector< unsigned char >::value_type"""
        return _oalib.uint8Vector_pop(self)


    def append(self, x):
        """append(uint8Vector self, std::vector< unsigned char >::value_type const & x)"""
        return _oalib.uint8Vector_append(self, x)


    def empty(self):
        """empty(uint8Vector self) -> bool"""
        return _oalib.uint8Vector_empty(self)


    def size(self):
        """size(uint8Vector self) -> std::vector< unsigned char >::size_type"""
        return _oalib.uint8Vector_size(self)


    def swap(self, v):
        """swap(uint8Vector self, uint8Vector v)"""
        return _oalib.uint8Vector_swap(self, v)


    def begin(self):
        """begin(uint8Vector self) -> std::vector< unsigned char >::iterator"""
        return _oalib.uint8Vector_begin(self)


    def end(self):
        """end(uint8Vector self) -> std::vector< unsigned char >::iterator"""
        return _oalib.uint8Vector_end(self)


    def rbegin(self):
        """rbegin(uint8Vector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _oalib.uint8Vector_rbegin(self)


    def rend(self):
        """rend(uint8Vector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _oalib.uint8Vector_rend(self)


    def clear(self):
        """clear(uint8Vector self)"""
        return _oalib.uint8Vector_clear(self)


    def get_allocator(self):
        """get_allocator(uint8Vector self) -> std::vector< unsigned char >::allocator_type"""
        return _oalib.uint8Vector_get_allocator(self)


    def pop_back(self):
        """pop_back(uint8Vector self)"""
        return _oalib.uint8Vector_pop_back(self)


    def erase(self, *args):
        """
        erase(uint8Vector self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(uint8Vector self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _oalib.uint8Vector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(unsigned char)> self) -> uint8Vector
        __init__(std::vector<(unsigned char)> self, uint8Vector arg2) -> uint8Vector
        __init__(std::vector<(unsigned char)> self, std::vector< unsigned char >::size_type size) -> uint8Vector
        __init__(std::vector<(unsigned char)> self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> uint8Vector
        """
        this = _oalib.new_uint8Vector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(uint8Vector self, std::vector< unsigned char >::value_type const & x)"""
        return _oalib.uint8Vector_push_back(self, x)


    def front(self):
        """front(uint8Vector self) -> std::vector< unsigned char >::value_type const &"""
        return _oalib.uint8Vector_front(self)


    def back(self):
        """back(uint8Vector self) -> std::vector< unsigned char >::value_type const &"""
        return _oalib.uint8Vector_back(self)


    def assign(self, n, x):
        """assign(uint8Vector self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _oalib.uint8Vector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(uint8Vector self, std::vector< unsigned char >::size_type new_size)
        resize(uint8Vector self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _oalib.uint8Vector_resize(self, *args)


    def insert(self, *args):
        """
        insert(uint8Vector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(uint8Vector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)
        """
        return _oalib.uint8Vector_insert(self, *args)


    def reserve(self, n):
        """reserve(uint8Vector self, std::vector< unsigned char >::size_type n)"""
        return _oalib.uint8Vector_reserve(self, n)


    def capacity(self):
        """capacity(uint8Vector self) -> std::vector< unsigned char >::size_type"""
        return _oalib.uint8Vector_capacity(self)

    __swig_destroy__ = _oalib.delete_uint8Vector
    __del__ = lambda self: None
uint8Vector_swigregister = _oalib.uint8Vector_swigregister
uint8Vector_swigregister(uint8Vector)

class charVector(object):
    """Proxy of C++ std::vector<(signed char)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(charVector self) -> SwigPyIterator"""
        return _oalib.charVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(charVector self) -> bool"""
        return _oalib.charVector___nonzero__(self)


    def __bool__(self):
        """__bool__(charVector self) -> bool"""
        return _oalib.charVector___bool__(self)


    def __len__(self):
        """__len__(charVector self) -> std::vector< signed char >::size_type"""
        return _oalib.charVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(charVector self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j) -> charVector"""
        return _oalib.charVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(charVector self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)
        __setslice__(charVector self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j, charVector v)
        """
        return _oalib.charVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(charVector self, std::vector< signed char >::difference_type i, std::vector< signed char >::difference_type j)"""
        return _oalib.charVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(charVector self, std::vector< signed char >::difference_type i)
        __delitem__(charVector self, PySliceObject * slice)
        """
        return _oalib.charVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(charVector self, PySliceObject * slice) -> charVector
        __getitem__(charVector self, std::vector< signed char >::difference_type i) -> std::vector< signed char >::value_type const &
        """
        return _oalib.charVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(charVector self, PySliceObject * slice, charVector v)
        __setitem__(charVector self, PySliceObject * slice)
        __setitem__(charVector self, std::vector< signed char >::difference_type i, std::vector< signed char >::value_type const & x)
        """
        return _oalib.charVector___setitem__(self, *args)


    def pop(self):
        """pop(charVector self) -> std::vector< signed char >::value_type"""
        return _oalib.charVector_pop(self)


    def append(self, x):
        """append(charVector self, std::vector< signed char >::value_type const & x)"""
        return _oalib.charVector_append(self, x)


    def empty(self):
        """empty(charVector self) -> bool"""
        return _oalib.charVector_empty(self)


    def size(self):
        """size(charVector self) -> std::vector< signed char >::size_type"""
        return _oalib.charVector_size(self)


    def swap(self, v):
        """swap(charVector self, charVector v)"""
        return _oalib.charVector_swap(self, v)


    def begin(self):
        """begin(charVector self) -> std::vector< signed char >::iterator"""
        return _oalib.charVector_begin(self)


    def end(self):
        """end(charVector self) -> std::vector< signed char >::iterator"""
        return _oalib.charVector_end(self)


    def rbegin(self):
        """rbegin(charVector self) -> std::vector< signed char >::reverse_iterator"""
        return _oalib.charVector_rbegin(self)


    def rend(self):
        """rend(charVector self) -> std::vector< signed char >::reverse_iterator"""
        return _oalib.charVector_rend(self)


    def clear(self):
        """clear(charVector self)"""
        return _oalib.charVector_clear(self)


    def get_allocator(self):
        """get_allocator(charVector self) -> std::vector< signed char >::allocator_type"""
        return _oalib.charVector_get_allocator(self)


    def pop_back(self):
        """pop_back(charVector self)"""
        return _oalib.charVector_pop_back(self)


    def erase(self, *args):
        """
        erase(charVector self, std::vector< signed char >::iterator pos) -> std::vector< signed char >::iterator
        erase(charVector self, std::vector< signed char >::iterator first, std::vector< signed char >::iterator last) -> std::vector< signed char >::iterator
        """
        return _oalib.charVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(signed char)> self) -> charVector
        __init__(std::vector<(signed char)> self, charVector arg2) -> charVector
        __init__(std::vector<(signed char)> self, std::vector< signed char >::size_type size) -> charVector
        __init__(std::vector<(signed char)> self, std::vector< signed char >::size_type size, std::vector< signed char >::value_type const & value) -> charVector
        """
        this = _oalib.new_charVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(charVector self, std::vector< signed char >::value_type const & x)"""
        return _oalib.charVector_push_back(self, x)


    def front(self):
        """front(charVector self) -> std::vector< signed char >::value_type const &"""
        return _oalib.charVector_front(self)


    def back(self):
        """back(charVector self) -> std::vector< signed char >::value_type const &"""
        return _oalib.charVector_back(self)


    def assign(self, n, x):
        """assign(charVector self, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)"""
        return _oalib.charVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(charVector self, std::vector< signed char >::size_type new_size)
        resize(charVector self, std::vector< signed char >::size_type new_size, std::vector< signed char >::value_type const & x)
        """
        return _oalib.charVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(charVector self, std::vector< signed char >::iterator pos, std::vector< signed char >::value_type const & x) -> std::vector< signed char >::iterator
        insert(charVector self, std::vector< signed char >::iterator pos, std::vector< signed char >::size_type n, std::vector< signed char >::value_type const & x)
        """
        return _oalib.charVector_insert(self, *args)


    def reserve(self, n):
        """reserve(charVector self, std::vector< signed char >::size_type n)"""
        return _oalib.charVector_reserve(self, n)


    def capacity(self):
        """capacity(charVector self) -> std::vector< signed char >::size_type"""
        return _oalib.charVector_capacity(self)

    __swig_destroy__ = _oalib.delete_charVector
    __del__ = lambda self: None
charVector_swigregister = _oalib.charVector_swigregister
charVector_swigregister(charVector)

class intVector(object):
    """Proxy of C++ std::vector<(int)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(intVector self) -> SwigPyIterator"""
        return _oalib.intVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(intVector self) -> bool"""
        return _oalib.intVector___nonzero__(self)


    def __bool__(self):
        """__bool__(intVector self) -> bool"""
        return _oalib.intVector___bool__(self)


    def __len__(self):
        """__len__(intVector self) -> std::vector< int >::size_type"""
        return _oalib.intVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j) -> intVector"""
        return _oalib.intVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __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 _oalib.intVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(intVector self, std::vector< int >::difference_type i, std::vector< int >::difference_type j)"""
        return _oalib.intVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(intVector self, std::vector< int >::difference_type i)
        __delitem__(intVector self, PySliceObject * slice)
        """
        return _oalib.intVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(intVector self, PySliceObject * slice) -> intVector
        __getitem__(intVector self, std::vector< int >::difference_type i) -> std::vector< int >::value_type const &
        """
        return _oalib.intVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __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 _oalib.intVector___setitem__(self, *args)


    def pop(self):
        """pop(intVector self) -> std::vector< int >::value_type"""
        return _oalib.intVector_pop(self)


    def append(self, x):
        """append(intVector self, std::vector< int >::value_type const & x)"""
        return _oalib.intVector_append(self, x)


    def empty(self):
        """empty(intVector self) -> bool"""
        return _oalib.intVector_empty(self)


    def size(self):
        """size(intVector self) -> std::vector< int >::size_type"""
        return _oalib.intVector_size(self)


    def swap(self, v):
        """swap(intVector self, intVector v)"""
        return _oalib.intVector_swap(self, v)


    def begin(self):
        """begin(intVector self) -> std::vector< int >::iterator"""
        return _oalib.intVector_begin(self)


    def end(self):
        """end(intVector self) -> std::vector< int >::iterator"""
        return _oalib.intVector_end(self)


    def rbegin(self):
        """rbegin(intVector self) -> std::vector< int >::reverse_iterator"""
        return _oalib.intVector_rbegin(self)


    def rend(self):
        """rend(intVector self) -> std::vector< int >::reverse_iterator"""
        return _oalib.intVector_rend(self)


    def clear(self):
        """clear(intVector self)"""
        return _oalib.intVector_clear(self)


    def get_allocator(self):
        """get_allocator(intVector self) -> std::vector< int >::allocator_type"""
        return _oalib.intVector_get_allocator(self)


    def pop_back(self):
        """pop_back(intVector self)"""
        return _oalib.intVector_pop_back(self)


    def erase(self, *args):
        """
        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 _oalib.intVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(int)> self) -> intVector
        __init__(std::vector<(int)> self, intVector arg2) -> intVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size) -> intVector
        __init__(std::vector<(int)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> intVector
        """
        this = _oalib.new_intVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(intVector self, std::vector< int >::value_type const & x)"""
        return _oalib.intVector_push_back(self, x)


    def front(self):
        """front(intVector self) -> std::vector< int >::value_type const &"""
        return _oalib.intVector_front(self)


    def back(self):
        """back(intVector self) -> std::vector< int >::value_type const &"""
        return _oalib.intVector_back(self)


    def assign(self, n, x):
        """assign(intVector self, std::vector< int >::size_type n, std::vector< int >::value_type const & x)"""
        return _oalib.intVector_assign(self, n, x)


    def resize(self, *args):
        """
        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 _oalib.intVector_resize(self, *args)


    def insert(self, *args):
        """
        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 _oalib.intVector_insert(self, *args)


    def reserve(self, n):
        """reserve(intVector self, std::vector< int >::size_type n)"""
        return _oalib.intVector_reserve(self, n)


    def capacity(self):
        """capacity(intVector self) -> std::vector< int >::size_type"""
        return _oalib.intVector_capacity(self)

    __swig_destroy__ = _oalib.delete_intVector
    __del__ = lambda self: None
intVector_swigregister = _oalib.intVector_swigregister
intVector_swigregister(intVector)

class longVector(object):
    """Proxy of C++ std::vector<(long)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(longVector self) -> SwigPyIterator"""
        return _oalib.longVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(longVector self) -> bool"""
        return _oalib.longVector___nonzero__(self)


    def __bool__(self):
        """__bool__(longVector self) -> bool"""
        return _oalib.longVector___bool__(self)


    def __len__(self):
        """__len__(longVector self) -> std::vector< long >::size_type"""
        return _oalib.longVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(longVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j) -> longVector"""
        return _oalib.longVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(longVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)
        __setslice__(longVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j, longVector v)
        """
        return _oalib.longVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(longVector self, std::vector< long >::difference_type i, std::vector< long >::difference_type j)"""
        return _oalib.longVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(longVector self, std::vector< long >::difference_type i)
        __delitem__(longVector self, PySliceObject * slice)
        """
        return _oalib.longVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(longVector self, PySliceObject * slice) -> longVector
        __getitem__(longVector self, std::vector< long >::difference_type i) -> std::vector< long >::value_type const &
        """
        return _oalib.longVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(longVector self, PySliceObject * slice, longVector v)
        __setitem__(longVector self, PySliceObject * slice)
        __setitem__(longVector self, std::vector< long >::difference_type i, std::vector< long >::value_type const & x)
        """
        return _oalib.longVector___setitem__(self, *args)


    def pop(self):
        """pop(longVector self) -> std::vector< long >::value_type"""
        return _oalib.longVector_pop(self)


    def append(self, x):
        """append(longVector self, std::vector< long >::value_type const & x)"""
        return _oalib.longVector_append(self, x)


    def empty(self):
        """empty(longVector self) -> bool"""
        return _oalib.longVector_empty(self)


    def size(self):
        """size(longVector self) -> std::vector< long >::size_type"""
        return _oalib.longVector_size(self)


    def swap(self, v):
        """swap(longVector self, longVector v)"""
        return _oalib.longVector_swap(self, v)


    def begin(self):
        """begin(longVector self) -> std::vector< long >::iterator"""
        return _oalib.longVector_begin(self)


    def end(self):
        """end(longVector self) -> std::vector< long >::iterator"""
        return _oalib.longVector_end(self)


    def rbegin(self):
        """rbegin(longVector self) -> std::vector< long >::reverse_iterator"""
        return _oalib.longVector_rbegin(self)


    def rend(self):
        """rend(longVector self) -> std::vector< long >::reverse_iterator"""
        return _oalib.longVector_rend(self)


    def clear(self):
        """clear(longVector self)"""
        return _oalib.longVector_clear(self)


    def get_allocator(self):
        """get_allocator(longVector self) -> std::vector< long >::allocator_type"""
        return _oalib.longVector_get_allocator(self)


    def pop_back(self):
        """pop_back(longVector self)"""
        return _oalib.longVector_pop_back(self)


    def erase(self, *args):
        """
        erase(longVector self, std::vector< long >::iterator pos) -> std::vector< long >::iterator
        erase(longVector self, std::vector< long >::iterator first, std::vector< long >::iterator last) -> std::vector< long >::iterator
        """
        return _oalib.longVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(long)> self) -> longVector
        __init__(std::vector<(long)> self, longVector arg2) -> longVector
        __init__(std::vector<(long)> self, std::vector< long >::size_type size) -> longVector
        __init__(std::vector<(long)> self, std::vector< long >::size_type size, std::vector< long >::value_type const & value) -> longVector
        """
        this = _oalib.new_longVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(longVector self, std::vector< long >::value_type const & x)"""
        return _oalib.longVector_push_back(self, x)


    def front(self):
        """front(longVector self) -> std::vector< long >::value_type const &"""
        return _oalib.longVector_front(self)


    def back(self):
        """back(longVector self) -> std::vector< long >::value_type const &"""
        return _oalib.longVector_back(self)


    def assign(self, n, x):
        """assign(longVector self, std::vector< long >::size_type n, std::vector< long >::value_type const & x)"""
        return _oalib.longVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(longVector self, std::vector< long >::size_type new_size)
        resize(longVector self, std::vector< long >::size_type new_size, std::vector< long >::value_type const & x)
        """
        return _oalib.longVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(longVector self, std::vector< long >::iterator pos, std::vector< long >::value_type const & x) -> std::vector< long >::iterator
        insert(longVector self, std::vector< long >::iterator pos, std::vector< long >::size_type n, std::vector< long >::value_type const & x)
        """
        return _oalib.longVector_insert(self, *args)


    def reserve(self, n):
        """reserve(longVector self, std::vector< long >::size_type n)"""
        return _oalib.longVector_reserve(self, n)


    def capacity(self):
        """capacity(longVector self) -> std::vector< long >::size_type"""
        return _oalib.longVector_capacity(self)

    __swig_destroy__ = _oalib.delete_longVector
    __del__ = lambda self: None
longVector_swigregister = _oalib.longVector_swigregister
longVector_swigregister(longVector)

class longDeque(object):
    """Proxy of C++ std::deque<(long)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(longDeque self) -> SwigPyIterator"""
        return _oalib.longDeque_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(longDeque self) -> bool"""
        return _oalib.longDeque___nonzero__(self)


    def __bool__(self):
        """__bool__(longDeque self) -> bool"""
        return _oalib.longDeque___bool__(self)


    def __len__(self):
        """__len__(longDeque self) -> std::deque< long >::size_type"""
        return _oalib.longDeque___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(longDeque self, std::deque< long >::difference_type i, std::deque< long >::difference_type j) -> longDeque"""
        return _oalib.longDeque___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(longDeque self, std::deque< long >::difference_type i, std::deque< long >::difference_type j)
        __setslice__(longDeque self, std::deque< long >::difference_type i, std::deque< long >::difference_type j, longDeque v)
        """
        return _oalib.longDeque___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(longDeque self, std::deque< long >::difference_type i, std::deque< long >::difference_type j)"""
        return _oalib.longDeque___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(longDeque self, std::deque< long >::difference_type i)
        __delitem__(longDeque self, PySliceObject * slice)
        """
        return _oalib.longDeque___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(longDeque self, PySliceObject * slice) -> longDeque
        __getitem__(longDeque self, std::deque< long >::difference_type i) -> std::deque< long >::value_type const &
        """
        return _oalib.longDeque___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(longDeque self, PySliceObject * slice, longDeque v)
        __setitem__(longDeque self, PySliceObject * slice)
        __setitem__(longDeque self, std::deque< long >::difference_type i, std::deque< long >::value_type const & x)
        """
        return _oalib.longDeque___setitem__(self, *args)


    def pop(self):
        """pop(longDeque self) -> std::deque< long >::value_type"""
        return _oalib.longDeque_pop(self)


    def append(self, x):
        """append(longDeque self, std::deque< long >::value_type const & x)"""
        return _oalib.longDeque_append(self, x)


    def empty(self):
        """empty(longDeque self) -> bool"""
        return _oalib.longDeque_empty(self)


    def size(self):
        """size(longDeque self) -> std::deque< long >::size_type"""
        return _oalib.longDeque_size(self)


    def swap(self, v):
        """swap(longDeque self, longDeque v)"""
        return _oalib.longDeque_swap(self, v)


    def begin(self):
        """begin(longDeque self) -> std::deque< long >::iterator"""
        return _oalib.longDeque_begin(self)


    def end(self):
        """end(longDeque self) -> std::deque< long >::iterator"""
        return _oalib.longDeque_end(self)


    def rbegin(self):
        """rbegin(longDeque self) -> std::deque< long >::reverse_iterator"""
        return _oalib.longDeque_rbegin(self)


    def rend(self):
        """rend(longDeque self) -> std::deque< long >::reverse_iterator"""
        return _oalib.longDeque_rend(self)


    def clear(self):
        """clear(longDeque self)"""
        return _oalib.longDeque_clear(self)


    def get_allocator(self):
        """get_allocator(longDeque self) -> std::deque< long >::allocator_type"""
        return _oalib.longDeque_get_allocator(self)


    def pop_back(self):
        """pop_back(longDeque self)"""
        return _oalib.longDeque_pop_back(self)


    def erase(self, *args):
        """
        erase(longDeque self, std::deque< long >::iterator pos) -> std::deque< long >::iterator
        erase(longDeque self, std::deque< long >::iterator first, std::deque< long >::iterator last) -> std::deque< long >::iterator
        """
        return _oalib.longDeque_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::deque<(long)> self) -> longDeque
        __init__(std::deque<(long)> self, longDeque arg2) -> longDeque
        __init__(std::deque<(long)> self, std::deque< long >::size_type size) -> longDeque
        __init__(std::deque<(long)> self, std::deque< long >::size_type size, std::deque< long >::value_type const & value) -> longDeque
        """
        this = _oalib.new_longDeque(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(longDeque self, std::deque< long >::value_type const & x)"""
        return _oalib.longDeque_push_back(self, x)


    def front(self):
        """front(longDeque self) -> std::deque< long >::value_type const &"""
        return _oalib.longDeque_front(self)


    def back(self):
        """back(longDeque self) -> std::deque< long >::value_type const &"""
        return _oalib.longDeque_back(self)


    def assign(self, n, x):
        """assign(longDeque self, std::deque< long >::size_type n, std::deque< long >::value_type const & x)"""
        return _oalib.longDeque_assign(self, n, x)


    def resize(self, *args):
        """
        resize(longDeque self, std::deque< long >::size_type new_size)
        resize(longDeque self, std::deque< long >::size_type new_size, std::deque< long >::value_type const & x)
        """
        return _oalib.longDeque_resize(self, *args)


    def insert(self, *args):
        """
        insert(longDeque self, std::deque< long >::iterator pos, std::deque< long >::value_type const & x) -> std::deque< long >::iterator
        insert(longDeque self, std::deque< long >::iterator pos, std::deque< long >::size_type n, std::deque< long >::value_type const & x)
        """
        return _oalib.longDeque_insert(self, *args)


    def pop_front(self):
        """pop_front(longDeque self)"""
        return _oalib.longDeque_pop_front(self)


    def push_front(self, x):
        """push_front(longDeque self, std::deque< long >::value_type const & x)"""
        return _oalib.longDeque_push_front(self, x)

    __swig_destroy__ = _oalib.delete_longDeque
    __del__ = lambda self: None
longDeque_swigregister = _oalib.longDeque_swigregister
longDeque_swigregister(longDeque)

class doubleVector(object):
    """Proxy of C++ std::vector<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(doubleVector self) -> SwigPyIterator"""
        return _oalib.doubleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(doubleVector self) -> bool"""
        return _oalib.doubleVector___nonzero__(self)


    def __bool__(self):
        """__bool__(doubleVector self) -> bool"""
        return _oalib.doubleVector___bool__(self)


    def __len__(self):
        """__len__(doubleVector self) -> std::vector< double >::size_type"""
        return _oalib.doubleVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(doubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> doubleVector"""
        return _oalib.doubleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(doubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(doubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, doubleVector v)
        """
        return _oalib.doubleVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(doubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _oalib.doubleVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(doubleVector self, std::vector< double >::difference_type i)
        __delitem__(doubleVector self, PySliceObject * slice)
        """
        return _oalib.doubleVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(doubleVector self, PySliceObject * slice) -> doubleVector
        __getitem__(doubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _oalib.doubleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(doubleVector self, PySliceObject * slice, doubleVector v)
        __setitem__(doubleVector self, PySliceObject * slice)
        __setitem__(doubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _oalib.doubleVector___setitem__(self, *args)


    def pop(self):
        """pop(doubleVector self) -> std::vector< double >::value_type"""
        return _oalib.doubleVector_pop(self)


    def append(self, x):
        """append(doubleVector self, std::vector< double >::value_type const & x)"""
        return _oalib.doubleVector_append(self, x)


    def empty(self):
        """empty(doubleVector self) -> bool"""
        return _oalib.doubleVector_empty(self)


    def size(self):
        """size(doubleVector self) -> std::vector< double >::size_type"""
        return _oalib.doubleVector_size(self)


    def swap(self, v):
        """swap(doubleVector self, doubleVector v)"""
        return _oalib.doubleVector_swap(self, v)


    def begin(self):
        """begin(doubleVector self) -> std::vector< double >::iterator"""
        return _oalib.doubleVector_begin(self)


    def end(self):
        """end(doubleVector self) -> std::vector< double >::iterator"""
        return _oalib.doubleVector_end(self)


    def rbegin(self):
        """rbegin(doubleVector self) -> std::vector< double >::reverse_iterator"""
        return _oalib.doubleVector_rbegin(self)


    def rend(self):
        """rend(doubleVector self) -> std::vector< double >::reverse_iterator"""
        return _oalib.doubleVector_rend(self)


    def clear(self):
        """clear(doubleVector self)"""
        return _oalib.doubleVector_clear(self)


    def get_allocator(self):
        """get_allocator(doubleVector self) -> std::vector< double >::allocator_type"""
        return _oalib.doubleVector_get_allocator(self)


    def pop_back(self):
        """pop_back(doubleVector self)"""
        return _oalib.doubleVector_pop_back(self)


    def erase(self, *args):
        """
        erase(doubleVector self, std::vector< double >::iterator pos) -> std::vector< double >::iterator
        erase(doubleVector self, std::vector< double >::iterator first, std::vector< double >::iterator last) -> std::vector< double >::iterator
        """
        return _oalib.doubleVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> doubleVector
        __init__(std::vector<(double)> self, doubleVector arg2) -> doubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> doubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> doubleVector
        """
        this = _oalib.new_doubleVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(doubleVector self, std::vector< double >::value_type const & x)"""
        return _oalib.doubleVector_push_back(self, x)


    def front(self):
        """front(doubleVector self) -> std::vector< double >::value_type const &"""
        return _oalib.doubleVector_front(self)


    def back(self):
        """back(doubleVector self) -> std::vector< double >::value_type const &"""
        return _oalib.doubleVector_back(self)


    def assign(self, n, x):
        """assign(doubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _oalib.doubleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(doubleVector self, std::vector< double >::size_type new_size)
        resize(doubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _oalib.doubleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(doubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(doubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _oalib.doubleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(doubleVector self, std::vector< double >::size_type n)"""
        return _oalib.doubleVector_reserve(self, n)


    def capacity(self):
        """capacity(doubleVector self) -> std::vector< double >::size_type"""
        return _oalib.doubleVector_capacity(self)

    __swig_destroy__ = _oalib.delete_doubleVector
    __del__ = lambda self: None
doubleVector_swigregister = _oalib.doubleVector_swigregister
doubleVector_swigregister(doubleVector)

class stringVector(object):
    """Proxy of C++ std::vector<(std::string)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(stringVector self) -> SwigPyIterator"""
        return _oalib.stringVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(stringVector self) -> bool"""
        return _oalib.stringVector___nonzero__(self)


    def __bool__(self):
        """__bool__(stringVector self) -> bool"""
        return _oalib.stringVector___bool__(self)


    def __len__(self):
        """__len__(stringVector self) -> std::vector< std::string >::size_type"""
        return _oalib.stringVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(stringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> stringVector"""
        return _oalib.stringVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __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 _oalib.stringVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(stringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _oalib.stringVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(stringVector self, std::vector< std::string >::difference_type i)
        __delitem__(stringVector self, PySliceObject * slice)
        """
        return _oalib.stringVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(stringVector self, PySliceObject * slice) -> stringVector
        __getitem__(stringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _oalib.stringVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __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 _oalib.stringVector___setitem__(self, *args)


    def pop(self):
        """pop(stringVector self) -> std::vector< std::string >::value_type"""
        return _oalib.stringVector_pop(self)


    def append(self, x):
        """append(stringVector self, std::vector< std::string >::value_type const & x)"""
        return _oalib.stringVector_append(self, x)


    def empty(self):
        """empty(stringVector self) -> bool"""
        return _oalib.stringVector_empty(self)


    def size(self):
        """size(stringVector self) -> std::vector< std::string >::size_type"""
        return _oalib.stringVector_size(self)


    def swap(self, v):
        """swap(stringVector self, stringVector v)"""
        return _oalib.stringVector_swap(self, v)


    def begin(self):
        """begin(stringVector self) -> std::vector< std::string >::iterator"""
        return _oalib.stringVector_begin(self)


    def end(self):
        """end(stringVector self) -> std::vector< std::string >::iterator"""
        return _oalib.stringVector_end(self)


    def rbegin(self):
        """rbegin(stringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _oalib.stringVector_rbegin(self)


    def rend(self):
        """rend(stringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _oalib.stringVector_rend(self)


    def clear(self):
        """clear(stringVector self)"""
        return _oalib.stringVector_clear(self)


    def get_allocator(self):
        """get_allocator(stringVector self) -> std::vector< std::string >::allocator_type"""
        return _oalib.stringVector_get_allocator(self)


    def pop_back(self):
        """pop_back(stringVector self)"""
        return _oalib.stringVector_pop_back(self)


    def erase(self, *args):
        """
        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 _oalib.stringVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> stringVector
        __init__(std::vector<(std::string)> self, stringVector arg2) -> stringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> stringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> stringVector
        """
        this = _oalib.new_stringVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(stringVector self, std::vector< std::string >::value_type const & x)"""
        return _oalib.stringVector_push_back(self, x)


    def front(self):
        """front(stringVector self) -> std::vector< std::string >::value_type const &"""
        return _oalib.stringVector_front(self)


    def back(self):
        """back(stringVector self) -> std::vector< std::string >::value_type const &"""
        return _oalib.stringVector_back(self)


    def assign(self, n, x):
        """assign(stringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _oalib.stringVector_assign(self, n, x)


    def resize(self, *args):
        """
        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 _oalib.stringVector_resize(self, *args)


    def insert(self, *args):
        """
        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 _oalib.stringVector_insert(self, *args)


    def reserve(self, n):
        """reserve(stringVector self, std::vector< std::string >::size_type n)"""
        return _oalib.stringVector_reserve(self, n)


    def capacity(self):
        """capacity(stringVector self) -> std::vector< std::string >::size_type"""
        return _oalib.stringVector_capacity(self)

    __swig_destroy__ = _oalib.delete_stringVector
    __del__ = lambda self: None
stringVector_swigregister = _oalib.stringVector_swigregister
stringVector_swigregister(stringVector)

class map_int_long(object):
    """Proxy of C++ std::map<(int,long)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(map_int_long self) -> SwigPyIterator"""
        return _oalib.map_int_long_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(map_int_long self) -> bool"""
        return _oalib.map_int_long___nonzero__(self)


    def __bool__(self):
        """__bool__(map_int_long self) -> bool"""
        return _oalib.map_int_long___bool__(self)


    def __len__(self):
        """__len__(map_int_long self) -> std::map< int,long >::size_type"""
        return _oalib.map_int_long___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(map_int_long self, std::map< int,long >::key_type const & key) -> std::map< int,long >::mapped_type const &"""
        return _oalib.map_int_long___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(map_int_long self, std::map< int,long >::key_type const & key)"""
        return _oalib.map_int_long___delitem__(self, key)


    def has_key(self, key):
        """has_key(map_int_long self, std::map< int,long >::key_type const & key) -> bool"""
        return _oalib.map_int_long_has_key(self, key)


    def keys(self):
        """keys(map_int_long self) -> PyObject *"""
        return _oalib.map_int_long_keys(self)


    def values(self):
        """values(map_int_long self) -> PyObject *"""
        return _oalib.map_int_long_values(self)


    def items(self):
        """items(map_int_long self) -> PyObject *"""
        return _oalib.map_int_long_items(self)


    def __contains__(self, key):
        """__contains__(map_int_long self, std::map< int,long >::key_type const & key) -> bool"""
        return _oalib.map_int_long___contains__(self, key)


    def key_iterator(self):
        """key_iterator(map_int_long self) -> SwigPyIterator"""
        return _oalib.map_int_long_key_iterator(self)


    def value_iterator(self):
        """value_iterator(map_int_long self) -> SwigPyIterator"""
        return _oalib.map_int_long_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(map_int_long self, std::map< int,long >::key_type const & key)
        __setitem__(map_int_long self, std::map< int,long >::key_type const & key, std::map< int,long >::mapped_type const & x)
        """
        return _oalib.map_int_long___setitem__(self, *args)


    def asdict(self):
        """asdict(map_int_long self) -> PyObject *"""
        return _oalib.map_int_long_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(int,long)> self, std::less< int > const & arg2) -> map_int_long
        __init__(std::map<(int,long)> self) -> map_int_long
        __init__(std::map<(int,long)> self, map_int_long arg2) -> map_int_long
        """
        this = _oalib.new_map_int_long(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        """empty(map_int_long self) -> bool"""
        return _oalib.map_int_long_empty(self)


    def size(self):
        """size(map_int_long self) -> std::map< int,long >::size_type"""
        return _oalib.map_int_long_size(self)


    def swap(self, v):
        """swap(map_int_long self, map_int_long v)"""
        return _oalib.map_int_long_swap(self, v)


    def begin(self):
        """begin(map_int_long self) -> std::map< int,long >::iterator"""
        return _oalib.map_int_long_begin(self)


    def end(self):
        """end(map_int_long self) -> std::map< int,long >::iterator"""
        return _oalib.map_int_long_end(self)


    def rbegin(self):
        """rbegin(map_int_long self) -> std::map< int,long >::reverse_iterator"""
        return _oalib.map_int_long_rbegin(self)


    def rend(self):
        """rend(map_int_long self) -> std::map< int,long >::reverse_iterator"""
        return _oalib.map_int_long_rend(self)


    def clear(self):
        """clear(map_int_long self)"""
        return _oalib.map_int_long_clear(self)


    def get_allocator(self):
        """get_allocator(map_int_long self) -> std::map< int,long >::allocator_type"""
        return _oalib.map_int_long_get_allocator(self)


    def count(self, x):
        """count(map_int_long self, std::map< int,long >::key_type const & x) -> std::map< int,long >::size_type"""
        return _oalib.map_int_long_count(self, x)


    def erase(self, *args):
        """
        erase(map_int_long self, std::map< int,long >::key_type const & x) -> std::map< int,long >::size_type
        erase(map_int_long self, std::map< int,long >::iterator position)
        erase(map_int_long self, std::map< int,long >::iterator first, std::map< int,long >::iterator last)
        """
        return _oalib.map_int_long_erase(self, *args)


    def find(self, x):
        """find(map_int_long self, std::map< int,long >::key_type const & x) -> std::map< int,long >::iterator"""
        return _oalib.map_int_long_find(self, x)


    def lower_bound(self, x):
        """lower_bound(map_int_long self, std::map< int,long >::key_type const & x) -> std::map< int,long >::iterator"""
        return _oalib.map_int_long_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(map_int_long self, std::map< int,long >::key_type const & x) -> std::map< int,long >::iterator"""
        return _oalib.map_int_long_upper_bound(self, x)

    __swig_destroy__ = _oalib.delete_map_int_long
    __del__ = lambda self: None
map_int_long_swigregister = _oalib.map_int_long_swigregister
map_int_long_swigregister(map_int_long)


import numpy


_oalib.MAXCOLS_swigconstant(_oalib)
MAXCOLS = _oalib.MAXCOLS

_oalib.MAXROWS_swigconstant(_oalib)
MAXROWS = _oalib.MAXROWS

_oalib.CLEAN_ARRAY_LINK_swigconstant(_oalib)
CLEAN_ARRAY_LINK = _oalib.CLEAN_ARRAY_LINK

_oalib.OACHECK_swigconstant(_oalib)
OACHECK = _oalib.OACHECK

_oalib.FREQELEM_swigconstant(_oalib)
FREQELEM = _oalib.FREQELEM

_oalib.SYMMBLOCKS_swigconstant(_oalib)
SYMMBLOCKS = _oalib.SYMMBLOCKS

_oalib.TPLUSCOLUMN_swigconstant(_oalib)
TPLUSCOLUMN = _oalib.TPLUSCOLUMN

_oalib.oacolSortName_swigconstant(_oalib)
oacolSortName = _oalib.oacolSortName

def compile_information():
    """
    compile_information() -> std::string

    std::string
    compile_information()

    Print the compile-time options to string. String with information 
    """
    return _oalib.compile_information()

def version():
    """
    version() -> std::string

    std::string version()

    Print version. 
    """
    return _oalib.version()

def print_copyright():
    """
    print_copyright()

    void print_copyright()

    Print copyright statement. 
    """
    return _oalib.print_copyright()

def print_copyright_old():
    """
    print_copyright_old()

    void
    print_copyright_old()

    Print copyright statement. 
    """
    return _oalib.print_copyright_old()

def print_copyright_light():
    """
    print_copyright_light()

    void
    print_copyright_light()

    Print copyright statement. 
    """
    return _oalib.print_copyright_light()

def print_options(*args):
    """
    print_options(std::ostream & outx)
    print_options()

    void print_options() 
    """
    return _oalib.print_options(*args)

def oadevelop():
    """
    oadevelop() -> int

    int oadevelop() 
    """
    return _oalib.oadevelop()

def ncombscacheNumber():
    """
    ncombscacheNumber() -> int

    int ncombscacheNumber() 
    """
    return _oalib.ncombscacheNumber()

def initncombscache(N):
    """
    initncombscache(int N)

    void initncombscache(int N)

    initialize datastructure, this function is not thread safe 
    """
    return _oalib.initncombscache(N)

def ncombscache(n, k):
    """
    ncombscache(int n, int k) -> long

    long ncombscache(int n, int k)

    return number of combinations from previously calculated results

    The results should be calculated with initncombscache 
    """
    return _oalib.ncombscache(n, k)

def fastrand():
    """
    fastrand() -> int

    int fastrand() 
    """
    return _oalib.fastrand()

def seedfastrand(s):
    """
    seedfastrand(int s)

    void seedfastrand(int s) 
    """
    return _oalib.seedfastrand(s)

def fastrandK(k):
    """
    fastrandK(int k) -> int

    int fastrandK(int k) 
    """
    return _oalib.fastrandK(k)

def set_srand(s):
    """
    set_srand(unsigned int s)

    void set_srand(unsigned int s)

    set the random number seed using srand 
    """
    return _oalib.set_srand(s)

def print_combinations(n, k):
    """
    print_combinations(int n, int k)

    void
    print_combinations(int n, int k) 
    """
    return _oalib.print_combinations(n, k)
class indexsort(object):
    """


    Class to sort data without moving the data in memory.

    The data is sorted by using a list of indices. A stable sort is being
    used.

    C++ includes: mathtools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    indices = _swig_property(_oalib.indexsort_indices_get, _oalib.indexsort_indices_set)

    def __init__(self, nn):
        """
        __init__(indexsort self, int nn) -> indexsort

        indexsort::indexsort(const std::vector< Type > &vals)

        Constructor for vector class. 
        """
        this = _oalib.new_indexsort(nn)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self):
        """
        show(indexsort self)

        void indexsort::show() const

        """
        return _oalib.indexsort_show(self)


    def issorted(self):
        """
        issorted(indexsort self) -> bool

        bool
        indexsort::issorted() const

        Returns true of the data is sorted ascending. 
        """
        return _oalib.indexsort_issorted(self)


    def issorteddescending(self):
        """
        issorteddescending(indexsort self) -> bool

        bool
        indexsort::issorteddescending() const

        Returns true of the data is sorted descending. 
        """
        return _oalib.indexsort_issorteddescending(self)

    __swig_destroy__ = _oalib.delete_indexsort
    __del__ = lambda self: None
indexsort_swigregister = _oalib.indexsort_swigregister
indexsort_swigregister(indexsort)
cvar = _oalib.cvar
HACK = cvar.HACK

class symmetry_group(object):
    """


    Class to describe the symmetry group of a list of elements.

    The class assumes the list is sorted. The symmetry group is then a
    direct product of full permutation groups.

    We do not implement this using templates because we want to export to
    Python.

    C++ includes: mathtools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    gidx = _swig_property(_oalib.symmetry_group_gidx_get, _oalib.symmetry_group_gidx_set)
    gstart = _swig_property(_oalib.symmetry_group_gstart_get, _oalib.symmetry_group_gstart_set)
    gsize = _swig_property(_oalib.symmetry_group_gsize_get, _oalib.symmetry_group_gsize_set)
    ngroups = _swig_property(_oalib.symmetry_group_ngroups_get, _oalib.symmetry_group_ngroups_set)
    n = _swig_property(_oalib.symmetry_group_n_get, _oalib.symmetry_group_n_set)
    ascending = _swig_property(_oalib.symmetry_group_ascending_get, _oalib.symmetry_group_ascending_set)

    def __init__(self, *args):
        """
        __init__(symmetry_group self, intVector vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, intVector vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, intVector vals) -> symmetry_group
        __init__(symmetry_group self, doubleVector vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, doubleVector vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, doubleVector vals) -> symmetry_group
        __init__(symmetry_group self, std::vector< float,std::allocator< float > > const & vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, std::vector< float,std::allocator< float > > const & vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, std::vector< float,std::allocator< float > > const & vals) -> symmetry_group
        __init__(symmetry_group self, std::vector< short,std::allocator< short > > const & vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, std::vector< short,std::allocator< short > > const & vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, std::vector< short,std::allocator< short > > const & vals) -> symmetry_group
        __init__(symmetry_group self, std::vector< unsigned int,std::allocator< unsigned int > > const & vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, std::vector< unsigned int,std::allocator< unsigned int > > const & vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, std::vector< unsigned int,std::allocator< unsigned int > > const & vals) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_double vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_double vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_double vals) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_int vals, bool ascending=True, int verbose=0) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_int vals, bool ascending=True) -> symmetry_group
        __init__(symmetry_group self, vector_mvalue_t_int vals) -> symmetry_group
        __init__(symmetry_group self, symmetry_group sgx) -> symmetry_group
        __init__(symmetry_group self) -> symmetry_group

        symmetry_group::symmetry_group()

        copy constructor 
        """
        this = _oalib.new_symmetry_group(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def permsize(self):
        """
        permsize(symmetry_group self) -> symmetry_group::perm_return_type

        perm_return_type
        symmetry_group::permsize() const

        return size of the group of all permutations respecting the symmetry

        """
        return _oalib.symmetry_group_permsize(self)


    def permsize_large(self):
        """
        permsize_large(symmetry_group self) -> InfInt

        InfInt
        symmetry_group::permsize_large() const

        return size of the group of all permutations respecting the symmetry

        """
        return _oalib.symmetry_group_permsize_large(self)


    def checkIndices(self):
        """
        checkIndices(symmetry_group self) -> intVector

        std::vector<int>
        symmetry_group::checkIndices() const

        list with indices set to check for symmetry reductions 
        """
        return _oalib.symmetry_group_checkIndices(self)


    def __repr__(self):
        """
        __repr__(symmetry_group self) -> std::string

        std::string
        symmetry_group::__repr__() const

        representation function (for python interface) 
        """
        return _oalib.symmetry_group___repr__(self)


    def show(self, verbose=1):
        """
        show(symmetry_group self, int verbose=1)
        show(symmetry_group self)

        void
        symmetry_group::show(int verbose=1) const

        show the symmetry group 
        """
        return _oalib.symmetry_group_show(self, verbose)

    __swig_destroy__ = _oalib.delete_symmetry_group
    __del__ = lambda self: None
symmetry_group_swigregister = _oalib.symmetry_group_swigregister
symmetry_group_swigregister(symmetry_group)

class symmetry_group_walker(object):
    """


    class to walk over all element of a symmetry group

    C++ includes: mathtools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    sg = _swig_property(_oalib.symmetry_group_walker_sg_get, _oalib.symmetry_group_walker_sg_set)
    perms = _swig_property(_oalib.symmetry_group_walker_perms_get, _oalib.symmetry_group_walker_perms_set)

    def __init__(self, sg):
        """
        __init__(symmetry_group_walker self, symmetry_group sg) -> symmetry_group_walker

        symmetry_group_walker::symmetry_group_walker(symmetry_group sg) 
        """
        this = _oalib.new_symmetry_group_walker(sg)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, verbose=1):
        """
        show(symmetry_group_walker self, int verbose=1)
        show(symmetry_group_walker self)

        void
        symmetry_group_walker::show(int verbose=1) const 
        """
        return _oalib.symmetry_group_walker_show(self, verbose)


    def init(self):
        """
        init(symmetry_group_walker self)

        void
        symmetry_group_walker::init() 
        """
        return _oalib.symmetry_group_walker_init(self)


    def next(self):
        """
        next(symmetry_group_walker self) -> bool

        bool
        symmetry_group_walker::next() 
        """
        return _oalib.symmetry_group_walker_next(self)


    def fullperm(self):
        """
        fullperm(symmetry_group_walker self) -> intVector

        std::vector<int> symmetry_group_walker::fullperm() const 
        """
        return _oalib.symmetry_group_walker_fullperm(self)

    __swig_destroy__ = _oalib.delete_symmetry_group_walker
    __del__ = lambda self: None
symmetry_group_walker_swigregister = _oalib.symmetry_group_walker_swigregister
symmetry_group_walker_swigregister(symmetry_group_walker)


def ipow(*args):
    """
    ipow(long x, long y) -> long
    ipow(unsigned int x, unsigned int p) -> unsigned int

    unsigned int ipow(unsigned int x,
    unsigned int p)

    Power of two unsigned integers. 
    """
    return _oalib.ipow(*args)

def powmo(n):
    """
    powmo(int n) -> int

    int powmo(int n)

    -1 to the power n (integer) 
    """
    return _oalib.powmo(n)

def eigenInfo(*args):
    """
    eigenInfo(MatrixFloat const m, char const * str, int verbose=1)
    eigenInfo(MatrixFloat const m, char const * str)
    eigenInfo(MatrixFloat const m)
    """
    return _oalib.eigenInfo(*args)

def eigen2numpyHelper(pymat1, n, m):
    """eigen2numpyHelper(double * pymat1, int n, MatrixFloat const & m)"""
    return _oalib.eigen2numpyHelper(pymat1, n, m)

def dummy():
    """dummy() -> Eigen::VectorXd"""
    return _oalib.dummy()

def dummy2():
    """dummy2() -> Eigen::MatrixXd"""
    return _oalib.dummy2()

def sizeof_array_t():
    """sizeof_array_t() -> int"""
    return _oalib.sizeof_array_t()

def Fval(N, strength):
    """Fval(int N, int strength) -> intVector"""
    return _oalib.Fval(N, strength)

def file_exists(*args):
    """
    file_exists(std::string const filename) -> bool
    file_exists(char const * filename) -> bool
    """
    return _oalib.file_exists(*args)

def oa_file_exists(*args):
    """
    oa_file_exists(char const * filename) -> bool
    oa_file_exists(std::string const filename) -> bool
    """
    return _oalib.oa_file_exists(*args)

def createJ2tableConference(confmatrix):
    """createJ2tableConference(array_link confmatrix) -> array_link"""
    return _oalib.createJ2tableConference(confmatrix)

def createJdtable(al):
    """createJdtable(array_link al) -> array_link"""
    return _oalib.createJdtable(al)

_oalib.ORDER_LEX_swigconstant(_oalib)
ORDER_LEX = _oalib.ORDER_LEX

_oalib.ORDER_J5_swigconstant(_oalib)
ORDER_J5 = _oalib.ORDER_J5
class arraydata_t(object):
    """


    Contains properties of the design (number of rows, columns, levels)

    Constructor: arrayclass = arraydata_t(s, N, strength,ncolumns)

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    N = _swig_property(_oalib.arraydata_t_N_get, _oalib.arraydata_t_N_set)
    ncols = _swig_property(_oalib.arraydata_t_ncols_get, _oalib.arraydata_t_ncols_set)
    strength = _swig_property(_oalib.arraydata_t_strength_get, _oalib.arraydata_t_strength_set)
    s = _swig_property(_oalib.arraydata_t_s_get, _oalib.arraydata_t_s_set)
    order = _swig_property(_oalib.arraydata_t_order_get, _oalib.arraydata_t_order_set)
    ncolgroups = _swig_property(_oalib.arraydata_t_ncolgroups_get, _oalib.arraydata_t_ncolgroups_set)
    colgroupindex = _swig_property(_oalib.arraydata_t_colgroupindex_get, _oalib.arraydata_t_colgroupindex_set)
    colgroupsize = _swig_property(_oalib.arraydata_t_colgroupsize_get, _oalib.arraydata_t_colgroupsize_set)
    oaindex = _swig_property(_oalib.arraydata_t_oaindex_get, _oalib.arraydata_t_oaindex_set)

    def __init__(self, *args):
        """
        __init__(arraydata_t self, array_t s, rowindex_t N, colindex_t strength, colindex_t ncols) -> arraydata_t
        __init__(arraydata_t self, intVector s, rowindex_t N, colindex_t strength, colindex_t ncols) -> arraydata_t
        __init__(arraydata_t self, array_t const * s_, rowindex_t N, colindex_t strength, colindex_t ncols) -> arraydata_t
        __init__(arraydata_t self, arraydata_t adp) -> arraydata_t
        __init__(arraydata_t self, arraydata_t adp, colindex_t newncols) -> arraydata_t
        __init__(arraydata_t self) -> arraydata_t

        arraydata_t::arraydata_t()

        copy constructor 
        """
        this = _oalib.new_arraydata_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_arraydata_t
    __del__ = lambda self: None

    def ismixed(self):
        """
        ismixed(arraydata_t self) -> bool

        bool
        arraydata_t::ismixed() const

        destructor

        return true if the array is of mixed type 
        """
        return _oalib.arraydata_t_ismixed(self)


    def is2level(self):
        """
        is2level(arraydata_t self) -> bool

        bool
        arraydata_t::is2level() const

        return true if the array is a 2-level array 
        """
        return _oalib.arraydata_t_is2level(self)


    def randomarray(self, strength=0, ncols=-1):
        """
        randomarray(arraydata_t self, int strength=0, int ncols=-1) -> array_link
        randomarray(arraydata_t self, int strength=0) -> array_link
        randomarray(arraydata_t self) -> array_link

        array_link
        arraydata_t::randomarray(int strength=0, int ncols=-1) const

        return random array from the class. this operation is only valid for
        strength 0 or 1 
        """
        return _oalib.arraydata_t_randomarray(self, strength, ncols)


    def writeConfigFile(self, filename):
        """
        writeConfigFile(arraydata_t self, char const * filename)

        void
        arraydata_t::writeConfigFile(const char *filename) const

        Write file with design of OA.

        Parameters:
        -----------

        file:

        ad:  Arraydata structure to write 
        """
        return _oalib.arraydata_t_writeConfigFile(self, filename)


    def __eq__(self, ad2):
        """__eq__(arraydata_t self, arraydata_t ad2) -> int"""
        return _oalib.arraydata_t___eq__(self, ad2)


    def idstr(self):
        """
        idstr(arraydata_t self) -> std::string

        std::string
        arraydata_t::idstr() const 
        """
        return _oalib.arraydata_t_idstr(self)


    def idstrseriesfull(self):
        """
        idstrseriesfull(arraydata_t self) -> std::string

        std::string
        arraydata_t::idstrseriesfull() const 
        """
        return _oalib.arraydata_t_idstrseriesfull(self)


    def fullidstr(self, series=0):
        """
        fullidstr(arraydata_t self, int series=0) -> std::string
        fullidstr(arraydata_t self) -> std::string

        std::string
        arraydata_t::fullidstr(int series=0) const 
        """
        return _oalib.arraydata_t_fullidstr(self, series)


    def latexstr(self, cmd=0, series=0):
        """
        latexstr(arraydata_t self, int cmd=0, int series=0) -> std::string
        latexstr(arraydata_t self, int cmd=0) -> std::string
        latexstr(arraydata_t self) -> std::string

        std::string
        arraydata_t::latexstr(int cmd=0, int series=0) const 
        """
        return _oalib.arraydata_t_latexstr(self, cmd, series)


    def reduceColumns(self, k):
        """
        reduceColumns(arraydata_t self, int k) -> arraydata_t

        arraydata_t
        arraydata_t::reduceColumns(int k) 
        """
        return _oalib.arraydata_t_reduceColumns(self, k)


    def showstr(self):
        """
        showstr(arraydata_t self) -> std::string

        std::string
        arraydata_t::showstr() const 
        """
        return _oalib.arraydata_t_showstr(self)


    def show(self, verbose=1):
        """
        show(arraydata_t self, int verbose=1)
        show(arraydata_t self)

        void arraydata_t::show(int
        verbose=1) const 
        """
        return _oalib.arraydata_t_show(self, verbose)


    def complete_arraydata(self):
        """
        complete_arraydata(arraydata_t self)

        void
        arraydata_t::complete_arraydata() 
        """
        return _oalib.arraydata_t_complete_arraydata(self)


    def lmc_overflow_check(self):
        """
        lmc_overflow_check(arraydata_t self)

        void
        arraydata_t::lmc_overflow_check() const

        check whether the LMC calculation will overflow 
        """
        return _oalib.arraydata_t_lmc_overflow_check(self)


    def complete_arraydata_fixlast(self):
        """
        complete_arraydata_fixlast(arraydata_t self)

        void
        arraydata_t::complete_arraydata_fixlast() 
        """
        return _oalib.arraydata_t_complete_arraydata_fixlast(self)


    def set_colgroups_jj(self, sg, jj):
        """
        set_colgroups_jj(arraydata_t self, symmetry_group sg, int jj)

        void
        arraydata_t::set_colgroups_jj(const symmetry_group &sg, int jj) 
        """
        return _oalib.arraydata_t_set_colgroups_jj(self, sg, jj)


    def set_colgroups(self, *args):
        """
        set_colgroups(arraydata_t self, intVector splits)
        set_colgroups(arraydata_t self, symmetry_group sg)

        void
        arraydata_t::set_colgroups(const symmetry_group &sg)

        set column group equal to that of a symmetry group 
        """
        return _oalib.arraydata_t_set_colgroups(self, *args)


    def show_colgroups(self):
        """
        show_colgroups(arraydata_t self)

        void
        arraydata_t::show_colgroups() const 
        """
        return _oalib.arraydata_t_show_colgroups(self)


    def calcoaindex(self, strength):
        """
        calcoaindex(arraydata_t self, colindex_t strength)

        void
        arraydata_t::calcoaindex(colindex_t strength) 
        """
        return _oalib.arraydata_t_calcoaindex(self, strength)


    def create_root(self):
        """
        create_root(arraydata_t self) -> array_link

        array_link
        arraydata_t::create_root() const

        return the root array for the class 
        """
        return _oalib.arraydata_t_create_root(self)


    def getfactorlevel(self, idx):
        """
        getfactorlevel(arraydata_t self, int idx) -> int

        int
        arraydata_t::getfactorlevel(int idx) const 
        """
        return _oalib.arraydata_t_getfactorlevel(self, idx)


    def getS(self):
        """
        getS(arraydata_t self) -> intVector

        std::vector< int >
        arraydata_t::getS() const 
        """
        return _oalib.arraydata_t_getS(self)


    def reset_strength(self, t):
        """
        reset_strength(arraydata_t self, colindex_t t)

        void
        arraydata_t::reset_strength(colindex_t t)

        Reset strength of arraydata.

        Parameters:
        -----------

        t:  
        """
        return _oalib.arraydata_t_reset_strength(self, t)


    def get_col_group(self, col):
        """
        get_col_group(arraydata_t self, colindex_t const col) -> colindex_t

        colindex_t
        arraydata_t::get_col_group(const colindex_t col) const

        Return index of the column group for a column. 
        """
        return _oalib.arraydata_t_get_col_group(self, col)


    def __repr__(self):
        """__repr__(arraydata_t self) -> std::string"""
        return _oalib.arraydata_t___repr__(self)

arraydata_t_swigregister = _oalib.arraydata_t_swigregister
arraydata_t_swigregister(arraydata_t)


def readConfigFile(file):
    """readConfigFile(char const * file) -> arraydata_t"""
    return _oalib.readConfigFile(file)

def copy_array(src, dst, nrows, ncols):
    """copy_array(array_t const * src, array_t *const dst, int const nrows, int const ncols)"""
    return _oalib.copy_array(src, dst, nrows, ncols)

def destroy_array(array):
    """destroy_array(array_t * array) -> int"""
    return _oalib.destroy_array(array)

def create_array(*args):
    """
    create_array(int const nrows, int const ncols) -> array_t
    create_array(arraydata_t ad) -> array_t *
    """
    return _oalib.create_array(*args)

def equal_array_cols(A, col, col2, nrows, rstart, rend):
    """equal_array_cols(carray_t * A, colindex_t col, colindex_t col2, rowindex_t nrows, rowindex_t rstart, rowindex_t rend) -> int"""
    return _oalib.equal_array_cols(A, col, col2, nrows, rstart, rend)

def clone_array(array, nrows, ncols):
    """clone_array(array_t const *const array, rowindex_t const nrows, colindex_t const ncols) -> array_t *"""
    return _oalib.clone_array(array, nrows, ncols)

def perform_inv_column_permutation(source, target, perm, nrows, ncols):
    """perform_inv_column_permutation(array_t const * source, array_t * target, colperm_t perm, int nrows, int ncols)"""
    return _oalib.perform_inv_column_permutation(source, target, perm, nrows, ncols)

def perform_inv_row_permutation(source, target, perm, nrows, ncols):
    """perform_inv_row_permutation(array_t const * source, array_t * target, rowperm_t perm, int nrows, int ncols)"""
    return _oalib.perform_inv_row_permutation(source, target, perm, nrows, ncols)

def exampleArray(idx=0, verbose=0):
    """
    exampleArray(int idx=0, int verbose=0) -> array_link
    exampleArray(int idx=0) -> array_link
    exampleArray() -> array_link
    """
    return _oalib.exampleArray(idx, verbose)

def Jcharacteristics_conference(al, jj, verbose=0):
    """
    Jcharacteristics_conference(array_link al, int jj, int verbose=0) -> intVector
    Jcharacteristics_conference(array_link al, int jj) -> intVector
    """
    return _oalib.Jcharacteristics_conference(al, jj, verbose)
class array_link(object):
    """


    Wrapper class for an array.

    The array_link struct is a struct that represents an arrays. Copying
    of array links is done with shallow copy or deep copy depending on
    compile time options!

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    n_rows = _swig_property(_oalib.array_link_n_rows_get, _oalib.array_link_n_rows_set)
    n_columns = _swig_property(_oalib.array_link_n_columns_get, _oalib.array_link_n_columns_set)
    index = _swig_property(_oalib.array_link_index_get, _oalib.array_link_index_set)
    array = _swig_property(_oalib.array_link_array_get, _oalib.array_link_array_set)
    INDEX_NONE = _oalib.array_link_INDEX_NONE
    INDEX_ERROR = _oalib.array_link_INDEX_ERROR
    INDEX_DEFAULT = _oalib.array_link_INDEX_DEFAULT
    __swig_destroy__ = _oalib.delete_array_link
    __del__ = lambda self: None

    def clone(self):
        """
        clone(array_link self) -> array_link

        array_link
        array_link::clone() const 
        """
        return _oalib.array_link_clone(self)


    def showarray(self):
        """
        showarray(array_link self)

        void
        array_link::showarray() const

        print array to stdout 
        """
        return _oalib.array_link_showarray(self)


    def showarraycompact(self):
        """
        showarraycompact(array_link self)

        void
        array_link::showarraycompact() const

        print array to stdout 
        """
        return _oalib.array_link_showarraycompact(self)


    def showproperties(self):
        """
        showproperties(array_link self)

        void
        array_link::showproperties() const

        print array properties to stdout 
        """
        return _oalib.array_link_showproperties(self)


    def is2level(self):
        """
        is2level(array_link self) -> bool

        bool
        array_link::is2level() const

        return true if the arra is a 2-level array (e.g. only contains 0 and
        1) 
        """
        return _oalib.array_link_is2level(self)


    def is_conference(self, *args):
        """
        is_conference(array_link self) -> bool
        is_conference(array_link self, int nz) -> bool

        bool
        array_link::is_conference() const

        return true if the array is a +1,0, -1 valued array 
        """
        return _oalib.array_link_is_conference(self, *args)


    def isSymmetric(self):
        """isSymmetric(array_link self) -> bool"""
        return _oalib.array_link_isSymmetric(self)


    def makeSymmetric(self):
        """makeSymmetric(array_link self)"""
        return _oalib.array_link_makeSymmetric(self)


    def deleteColumn(self, index):
        """
        deleteColumn(array_link self, int index) -> array_link

        array_link
        array_link::deleteColumn(int index) const

        return array with selected column removed 
        """
        return _oalib.array_link_deleteColumn(self, index)


    def selectFirstRows(self, n):
        """
        selectFirstRows(array_link self, int n) -> array_link

        array_link
        array_link::selectFirstRows(int n) const

        return array with first n rows 
        """
        return _oalib.array_link_selectFirstRows(self, n)


    def selectFirstColumns(self, n):
        """
        selectFirstColumns(array_link self, int n) -> array_link

        array_link
        array_link::selectFirstColumns(int n) const

        return array with first n columns selected 
        """
        return _oalib.array_link_selectFirstColumns(self, n)


    def selectLastColumns(self, n):
        """
        selectLastColumns(array_link self, int n) -> array_link

        array_link
        array_link::selectLastColumns(int n) const

        return array with last n columns selected 
        """
        return _oalib.array_link_selectLastColumns(self, n)


    def selectColumns(self, *args):
        """
        selectColumns(array_link self, intVector c) -> array_link
        selectColumns(array_link self, int c) -> array_link

        array_link
        array_link::selectColumns(int c) const

        select single column from an array 
        """
        return _oalib.array_link_selectColumns(self, *args)


    def setColumn(self, *args):
        """
        setColumn(array_link self, int c, intVector v)
        setColumn(array_link self, int c, charVector v)

        void
        array_link::setColumn(int c, const std::vector< signed char >v) 
        """
        return _oalib.array_link_setColumn(self, *args)


    def transposed(self):
        """
        transposed(array_link self) -> array_link

        array_link
        array_link::transposed() const

        return transposed array 
        """
        return _oalib.array_link_transposed(self)


    def Defficiency(self):
        """
        Defficiency(array_link self) -> double

        double
        array_link::Defficiency() const

        calculate D-efficiency 
        """
        return _oalib.array_link_Defficiency(self)


    def DsEfficiency(self, verbose=0):
        """
        DsEfficiency(array_link self, int verbose=0) -> double
        DsEfficiency(array_link self) -> double

        double
        array_link::DsEfficiency(int verbose=0) const

        calculate main effect robustness (or Ds-optimality) 
        """
        return _oalib.array_link_DsEfficiency(self, verbose)


    def Defficiencies(self, verbose=0, addDs0=0):
        """
        Defficiencies(array_link self, int verbose=0, int addDs0=0) -> doubleVector
        Defficiencies(array_link self, int verbose=0) -> doubleVector
        Defficiencies(array_link self) -> doubleVector

        std::vector< double
        > array_link::Defficiencies(int verbose=0, int addDs0=0) const

        calculate D-efficiency, calculate main effect robustness (or Ds-
        optimality) and D1-efficiency 
        """
        return _oalib.array_link_Defficiencies(self, verbose, addDs0)


    def VIFefficiency(self):
        """
        VIFefficiency(array_link self) -> double

        double
        array_link::VIFefficiency() const 
        """
        return _oalib.array_link_VIFefficiency(self)


    def Aefficiency(self):
        """
        Aefficiency(array_link self) -> double

        double
        array_link::Aefficiency() const

        calculate A-efficiency 
        """
        return _oalib.array_link_Aefficiency(self)


    def Eefficiency(self):
        """
        Eefficiency(array_link self) -> double

        double
        array_link::Eefficiency() const

        calculate E-efficiency 
        """
        return _oalib.array_link_Eefficiency(self)


    def Fvalues(self, jj):
        """
        Fvalues(array_link self, int jj) -> intVector

        std::vector< int >
        array_link::Fvalues(int jj) const

        Calculate F-values of a 2-level matrix. 
        """
        return _oalib.array_link_Fvalues(self, jj)


    def FvaluesConference(self, jj):
        """
        FvaluesConference(array_link self, int jj) -> intVector

        std::vector<
        int > array_link::FvaluesConference(int jj) const

        Calculate F-values of a conference design. 
        """
        return _oalib.array_link_FvaluesConference(self, jj)


    def Jcharacteristics(self, jj=4):
        """
        Jcharacteristics(array_link self, int jj=4) -> intVector
        Jcharacteristics(array_link self) -> intVector

        std::vector< int
        > array_link::Jcharacteristics(int jj=4) const

        Calculate J-characteristics of matrix (the values are signed) 
        """
        return _oalib.array_link_Jcharacteristics(self, jj)


    def PECsequence(self):
        """
        PECsequence(array_link self) -> doubleVector

        std::vector< double >
        array_link::PECsequence() const

        Calculate the projective estimation capacity sequence. 
        """
        return _oalib.array_link_PECsequence(self)


    def rank(self):
        """
        rank(array_link self) -> int

        int array_link::rank() const

        calculate rank of array 
        """
        return _oalib.array_link_rank(self)


    def GWLP(self, truncate=1, verbose=0):
        """
        GWLP(array_link self, int truncate=1, int verbose=0) -> doubleVector
        GWLP(array_link self, int truncate=1) -> doubleVector
        GWLP(array_link self) -> doubleVector

        std::vector< double >
        array_link::GWLP(int truncate=1, int verbose=0) const

        calculate generalized wordlength pattern 
        """
        return _oalib.array_link_GWLP(self, truncate, verbose)


    def strength(self):
        """
        strength(array_link self) -> int

        int
        array_link::strength() const

        calculate strength of an array 
        """
        return _oalib.array_link_strength(self)


    def foldover(self):
        """
        foldover(array_link self) -> bool

        bool
        array_link::foldover() const

        return true if the array is a foldover array 
        """
        return _oalib.array_link_foldover(self)


    def min(self):
        """
        min(array_link self) -> array_t

        array_t array_link::min()
        const 
        """
        return _oalib.array_link_min(self)


    def max(self):
        """
        max(array_link self) -> array_t

        array_t array_link::max()
        const 
        """
        return _oalib.array_link_max(self)


    def CL2discrepancy(self):
        """
        CL2discrepancy(array_link self) -> double

        double
        array_link::CL2discrepancy() const

        calculate centered L2 discrepancy

        The method is from "A connection between uniformity and aberration in
        regular fractions of two-level factorials", Fang and Mukerjee, 2000

        """
        return _oalib.array_link_CL2discrepancy(self)


    def randomperm(self):
        """
        randomperm(array_link self) -> array_link

        array_link
        array_link::randomperm() const

        apply a random permutation of rows, columns and levels 
        """
        return _oalib.array_link_randomperm(self)


    def randomcolperm(self):
        """
        randomcolperm(array_link self) -> array_link

        array_link
        array_link::randomcolperm() const

        apply a random permutation of columns 
        """
        return _oalib.array_link_randomcolperm(self)


    def randomrowperm(self):
        """
        randomrowperm(array_link self) -> array_link

        array_link
        array_link::randomrowperm() const

        apply a random permutation of row 
        """
        return _oalib.array_link_randomrowperm(self)


    def getModelMatrix(self, order, intercept=1):
        """
        getModelMatrix(array_link self, int order, int intercept=1) -> MatrixFloat
        getModelMatrix(array_link self, int order) -> MatrixFloat

        MatrixFloat
        array_link::getModelMatrix(int order, int intercept=1) const

        This function calculates Helmert contrasts for the factors of an input
        design. implementation from code written by Eric Schoen, Dept. of
        Applied Economics, University of Antwerp, Belgium 
        """
        return _oalib.array_link_getModelMatrix(self, order, intercept)


    def deepcopy(self, rhs):
        """
        deepcopy(array_link self, array_link rhs) -> array_link

        array_link &
        array_link::deepcopy(const array_link &rhs) 
        """
        return _oalib.array_link_deepcopy(self, rhs)


    def shallowcopy(self, rhs):
        """
        shallowcopy(array_link self, array_link rhs) -> array_link

        array_link &
        array_link::shallowcopy(const array_link &rhs) 
        """
        return _oalib.array_link_shallowcopy(self, rhs)


    def __eq__(self, rhs):
        """__eq__(array_link self, array_link rhs) -> int"""
        return _oalib.array_link___eq__(self, rhs)


    def __ne__(self, rhs):
        """__ne__(array_link self, array_link rhs) -> int"""
        return _oalib.array_link___ne__(self, rhs)


    def __lt__(self, rhs):
        """__lt__(array_link self, array_link rhs) -> int"""
        return _oalib.array_link___lt__(self, rhs)


    def __gt__(self, rhs):
        """__gt__(array_link self, array_link rhs) -> int"""
        return _oalib.array_link___gt__(self, rhs)


    def equalsize(self, rhs):
        """
        equalsize(array_link self, array_link rhs) -> int

        int
        array_link::equalsize(const array_link &rhs) const 
        """
        return _oalib.array_link_equalsize(self, rhs)


    def __add__(self, *args):
        """
        __add__(array_link self, array_link arg2) -> array_link
        __add__(array_link self, array_t v) -> array_link
        """
        return _oalib.array_link___add__(self, *args)


    def __sub__(self, *args):
        """
        __sub__(array_link self, array_link arg2) -> array_link
        __sub__(array_link self, array_t v) -> array_link
        """
        return _oalib.array_link___sub__(self, *args)


    def __mul__(self, *args):
        """
        __mul__(array_link self, array_link rhs) -> array_link
        __mul__(array_link self, array_t val) -> array_link
        """
        return _oalib.array_link___mul__(self, *args)


    def __imul__(self, val):
        """__imul__(array_link self, array_t val) -> array_link"""
        return _oalib.array_link___imul__(self, val)


    def __iadd__(self, val):
        """__iadd__(array_link self, array_t val) -> array_link"""
        return _oalib.array_link___iadd__(self, val)


    def __isub__(self, val):
        """__isub__(array_link self, array_t val) -> array_link"""
        return _oalib.array_link___isub__(self, val)


    def atfast(self, *args):
        """
        atfast(array_link self, rowindex_t const r, colindex_t const c) -> array_t const
        atfast(array_link self, rowindex_t const r, colindex_t const c) -> array_t &

        array_t&
        array_link::atfast(const rowindex_t r, const colindex_t c)

        get element from array, no error checking, inline version 
        """
        return _oalib.array_link_atfast(self, *args)


    def _at(self, *args):
        """
        _at(array_link self, rowindex_t const arg2, colindex_t const arg3) -> array_t
        _at(array_link self, int const index) -> array_t

        array_t array_link::_at(const
        int index) const

        get element at specified position, no error checking 
        """
        return _oalib.array_link__at(self, *args)


    def at(self, *args):
        """
        at(array_link self, rowindex_t const arg2, colindex_t const arg3) -> array_t
        at(array_link self, int const index) -> array_t
        at(array_link self, rowindex_t const arg2, colindex_t const arg3) -> array_t &

        array_t& array_link::at(const
        rowindex_t, const colindex_t)

        get element at specified position 
        """
        return _oalib.array_link_at(self, *args)


    def setconstant(self, val):
        """
        setconstant(array_link self, array_t val)

        void
        array_link::setconstant(array_t val)

        get element at specified position

        set all elements in the array to a value 
        """
        return _oalib.array_link_setconstant(self, val)


    def setvalue(self, *args):
        """
        setvalue(array_link self, int row, int col, int val)
        setvalue(array_link self, int row, int col, double val)

        void
        array_link::setvalue(int row, int col, double val) 
        """
        return _oalib.array_link_setvalue(self, *args)


    def _setvalue(self, row, col, val):
        """
        _setvalue(array_link self, int row, int col, int val)

        void
        array_link::_setvalue(int row, int col, int val)

        set value of an array 
        """
        return _oalib.array_link__setvalue(self, row, col, val)


    def negateRow(self, r):
        """
        negateRow(array_link self, rowindex_t r)

        void
        array_link::negateRow(rowindex_t r)

        set value of an array, no error checking!

        multiply a row by -1 
        """
        return _oalib.array_link_negateRow(self, r)


    def show(self):
        """
        show(array_link self)

        void array_link::show()
        const

        print information about array 
        """
        return _oalib.array_link_show(self)


    def showstr(self):
        """
        showstr(array_link self) -> std::string

        std::string
        array_link::showstr() const 
        """
        return _oalib.array_link_showstr(self)


    def md5(self):
        """
        md5(array_link self) -> std::string

        std::string array_link::md5()
        const

        return md5 sum of array representation (as represented with 32bit int
        datatype in memory) 
        """
        return _oalib.array_link_md5(self)


    def columnEqual(self, rl, rhs, rr):
        """
        columnEqual(array_link self, int rl, array_link rhs, int rr) -> bool

        bool
        array_link::columnEqual(int rl, const array_link &rhs, int rr) const

        return true if two columns are equal 
        """
        return _oalib.array_link_columnEqual(self, rl, rhs, rr)


    def firstColumnDifference(self, A):
        """
        firstColumnDifference(array_link self, array_link A) -> int

        int
        array_link::firstColumnDifference(const array_link &A) const

        return index of first different column 
        """
        return _oalib.array_link_firstColumnDifference(self, A)


    def firstDiff(self, A, r, c, verbose=1):
        """
        firstDiff(array_link self, array_link A, int & r, int & c, int verbose=1) -> bool
        firstDiff(array_link self, array_link A, int & r, int & c) -> bool

        bool
        array_link::firstDiff(const array_link &A, int &r, int &c, int
        verbose=1) const

        calculate row and column index of first difference between two arrays

        The difference is according to the column-major ordering. 
        """
        return _oalib.array_link_firstDiff(self, A, r, c, verbose)


    def create_root(self, ad):
        """
        create_root(array_link self, arraydata_t ad)

        void
        array_link::create_root(const arraydata_t &ad)

        create root in arraylink 
        """
        return _oalib.array_link_create_root(self, ad)


    def nonzero_fraction(self):
        """
        nonzero_fraction(array_link self) -> double

        double
        array_link::nonzero_fraction() const 
        """
        return _oalib.array_link_nonzero_fraction(self)


    def clear(self):
        """
        clear(array_link self)

        void array_link::clear()

        fill array with zeros 
        """
        return _oalib.array_link_clear(self)


    def getarraydata(self, pymat1):
        """
        getarraydata(array_link self, int * pymat1)

        void
        array_link::getarraydata(int *pymat1, int n) 
        """
        return _oalib.array_link_getarraydata(self, pymat1)


    def setarraydata(self, tmp, n):
        """
        setarraydata(array_link self, intVector tmp, int n)

        void
        array_link::setarraydata(std::vector< numtype > tmp, int n)

        internal function 
        """
        return _oalib.array_link_setarraydata(self, tmp, n)


    def maxelement(self):
        """
        maxelement(array_link self) -> array_t

        array_t
        array_link::maxelement() const 
        """
        return _oalib.array_link_maxelement(self)


    def setcolumn(self, c, al, sc=0):
        """
        setcolumn(array_link self, int c, array_link al, int sc=0)
        setcolumn(array_link self, int c, array_link al)

        void
        array_link::setcolumn(int c, const array_link &al, int sc=0)

        set column to values 
        """
        return _oalib.array_link_setcolumn(self, c, al, sc)


    def __init__(self, *args):
        """
        __init__(array_link self) -> array_link
        __init__(array_link self, rowindex_t nrows, colindex_t ncols, int index) -> array_link
        __init__(array_link self, rowindex_t nrows, colindex_t ncols, int index, carray_t * data) -> array_link
        __init__(array_link self, array_link arg2) -> array_link
        __init__(array_link self, Eigen::MatrixXd & m) -> array_link
        __init__(array_link self, long * pymatinput) -> array_link
        __init__(array_link self, array_link arg2, intVector colperm) -> array_link
        __init__(array_link self, array_t const * array, rowindex_t nrows, colindex_t ncols, int index=0) -> array_link
        __init__(array_link self, array_t const * array, rowindex_t nrows, colindex_t ncols) -> array_link
        __init__(array_link self, array_t const * array, rowindex_t nrows, colindex_t ncolsorig, colindex_t ncols, int index) -> array_link
        __init__(array_link self, intVector v, rowindex_t nrows, colindex_t ncols, int index=0) -> array_link
        __init__(array_link self, intVector v, rowindex_t nrows, colindex_t ncols) -> array_link

        array_link::array_link(const std::vector< int > &v, rowindex_t nrows,
        colindex_t ncols, int index=0) 
        """
        this = _oalib.new_array_link(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def init(self, r, c):
        """
        init(array_link self, rowindex_t r, colindex_t c)

        void
        array_link::init(rowindex_t r, colindex_t c) 
        """
        return _oalib.array_link_init(self, r, c)


    def row_symmetry_group(self):
        """
        row_symmetry_group(array_link self) -> symmetry_group

        symmetry_group
        array_link::row_symmetry_group() const

        return the row_symmetry group of an array 
        """
        return _oalib.array_link_row_symmetry_group(self)


    def reduceLMC(self):
        """
        reduceLMC(array_link self) -> array_link

        array_link
        array_link::reduceLMC() const

        return the LMC form of the array 
        """
        return _oalib.array_link_reduceLMC(self)


    def reduceDOP(self):
        """
        reduceDOP(array_link self) -> array_link

        array_link
        array_link::reduceDOP() const

        return the delete-one-factor-projection form of the array 
        """
        return _oalib.array_link_reduceDOP(self)


    def getEigenMatrix(self):
        """
        getEigenMatrix(array_link self) -> MatrixFloat

        MatrixFloat
        array_link::getEigenMatrix() const

        return the array as an Eigen matrix 
        """
        return _oalib.array_link_getEigenMatrix(self)


    def columnGreater(self, c1, rhs, c2):
        """
        columnGreater(array_link self, int c1, array_link rhs, int c2) -> int

        int
        array_link::columnGreater(int c1, const array_link &rhs, int c2) const

        return true of specified column is smaller than column in another
        array 
        """
        return _oalib.array_link_columnGreater(self, c1, rhs, c2)


    def showarrayS(self):
        """
        showarrayS(array_link self) -> std::string

        std::string
        array_link::showarrayS() const 
        """
        return _oalib.array_link_showarrayS(self)


    def debug(self):
        """debug(array_link self)"""
        return _oalib.array_link_debug(self)


    def data(self):
        """data(array_link self) -> void *"""
        return _oalib.array_link_data(self)



    def __getattr__(self, attr):
        if attr=='__array_interface__':
          a = dict()
          a['version']=3
          a['shape']=(self.n_rows, self.n_columns)
          sizeofdata=_oalib.sizeof_array_t()
          a['typestr']='<i%d' % sizeofdata # sizeof(array_t)
          a['data']=(self.data(), True)
    # convert from the OAP column-major style to Numpy row-major style
          a['strides']=(sizeofdata, sizeofdata*self.n_rows)
          return a
        else:
          raise AttributeError("%r object has no attribute %r" %
                             (self.__class__, attr))

    def showarray(self):
      """ Show array"""
    # overridden to fix problems with ipython
    #print(self.showarrayS(), end='',flush=True)	# not valid in python2
      sys.stdout.write(self.showarrayS())

    def getarray(self, verbose=0, *args):
      """ Return Numpy style array """
      if verbose:
          print('getting array: size %d %d' % (self.n_rows, self.n_columns))
      x=self.getarraydata( int(self.n_rows*self.n_columns) )
      return x.reshape((self.n_columns, self.n_rows)).transpose()
    #$action
    def setarray(self, X, verbose=0):
      self.init(X.shape[0], X.shape[1])
      self.index=-1
      iv = intVector(X.T.astype(int).flatten().tolist())
    #iv =_oalib.intVector(X.flatten().tolist())
      self.setarraydata(iv, X.size)
    def __getitem__(self,index):
      """ Return element of array """
      if type(index)==int:
          if index<0 or index > self.n_rows*self.n_columns:
            raise IndexError('index out of bounds')
          return self.at(index)
      else:
          if len(index)==2:
    # FIXME: error checking
            a=index[0]
            b=index[1]
            if a<0 or a >= self.n_rows:
              raise IndexError('index out of bounds')
            if b<0 or b >= self.n_columns:
              raise IndexError('index out of bounds')
            return self.at(a, b)	  
          else:
            raise IndexError('invalid index')
    def __setitem__(self,index, value):
      if type(index)==int:
          if index<0 or index > self.n_rows*self.n_columns:
            raise IndexError('index out of bounds')
          self.setvalue(index, 0, value) 
      else:
          if len(index)==2:
            a=index[0]
            b=index[1]
            if a<0 or a >= self.n_rows:
              raise IndexError('index out of bounds')
            if b<0 or b >= self.n_columns:
              raise IndexError('index out of bounds')
            self.setvalue(a, b, value)
          else:
            raise IndexError('invalid index')


    def __repr__(self):
        """__repr__(array_link self) -> std::string"""
        return _oalib.array_link___repr__(self)

array_link_swigregister = _oalib.array_link_swigregister
array_link_swigregister(array_link)


def hstack(*args):
    """
    hstack(array_link al, array_link b) -> array_link
    hstack(array_link al, charVector b) -> array_link
    """
    return _oalib.hstack(*args)

def hstacklastcol(A, B):
    """hstacklastcol(array_link A, array_link B) -> array_link"""
    return _oalib.hstacklastcol(A, B)

def vstack(A, B):
    """vstack(charVector A, charVector B) -> charVector"""
    return _oalib.vstack(A, B)

def perform_column_permutation(*args):
    """
    perform_column_permutation(carray_t * source, array_t * target, colperm_t perm, int nrows, int ncols)
    perform_column_permutation(array_link source, array_link target, intVector perm)
    """
    return _oalib.perform_column_permutation(*args)

def perform_row_permutation(*args):
    """
    perform_row_permutation(array_t const * source, array_t * target, rowperm_t perm, int nrows, int ncols)
    perform_row_permutation(array_link source, array_link target, intVector perm)
    """
    return _oalib.perform_row_permutation(*args)

def arraylink2arraydata(al, extracols=0, strength=2):
    """
    arraylink2arraydata(array_link al, int extracols=0, int strength=2) -> arraydata_t
    arraylink2arraydata(array_link al, int extracols=0) -> arraydata_t
    arraylink2arraydata(array_link al) -> arraydata_t
    """
    return _oalib.arraylink2arraydata(al, extracols, strength)

def addConstant(lst, v):
    """addConstant(arraylist_t lst, int v) -> arraylist_t"""
    return _oalib.addConstant(lst, v)

def getJcounts(arraylist, N, k, verbose=1):
    """
    getJcounts(arraylist_t arraylist, int N, int k, int verbose=1) -> intVector
    getJcounts(arraylist_t arraylist, int N, int k) -> intVector
    """
    return _oalib.getJcounts(arraylist, N, k, verbose)

def predictJ(array, N, k):
    """predictJ(array_t const * array, int const N, int const k) -> int"""
    return _oalib.predictJ(array, N, k)
class jstructbase_t(object):
    """


    struct to hold data of an array, e.g. J-characteristic. Abstract base
    class

    C++ includes: arraytools.h 
    """

    thisown = _swig_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
    values = _swig_property(_oalib.jstructbase_t_values_get, _oalib.jstructbase_t_values_set)
    jvalues = _swig_property(_oalib.jstructbase_t_jvalues_get, _oalib.jstructbase_t_jvalues_set)
    jvalue2index = _swig_property(_oalib.jstructbase_t_jvalue2index_get, _oalib.jstructbase_t_jvalue2index_set)
    jj = _swig_property(_oalib.jstructbase_t_jj_get, _oalib.jstructbase_t_jj_set)

    def maxJ(self):
        """
        maxJ(jstructbase_t self) -> int

        int jstructbase_t::maxJ()
        const

        calculate maximum J value 
        """
        return _oalib.jstructbase_t_maxJ(self)


    def Jvalues(self):
        """
        Jvalues(jstructbase_t self) -> intVector

        std::vector< int >
        jstructbase_t::Jvalues() const

        calculate possible values in F vector 
        """
        return _oalib.jstructbase_t_Jvalues(self)


    def calculateF(self):
        """
        calculateF(jstructbase_t self) -> intVector

        std::vector< int >
        jstructbase_t::calculateF() const

        calculate histogram of J values 
        """
        return _oalib.jstructbase_t_calculateF(self)


    def calc(self, al):
        """
        calc(jstructbase_t self, array_link al)

        virtual void
        jstructbase_t::calc(const array_link &al)=0 
        """
        return _oalib.jstructbase_t_calc(self, al)


    def show(self):
        """
        show(jstructbase_t self)

        void
        jstructbase_t::show()

        Show contents of structure. 
        """
        return _oalib.jstructbase_t_show(self)


    def showdata(self, verbose=1):
        """
        showdata(jstructbase_t self, int verbose=1)
        showdata(jstructbase_t self)

        void
        jstructbase_t::showdata(int verbose=1) 
        """
        return _oalib.jstructbase_t_showdata(self, verbose)


    def showstr(self):
        """
        showstr(jstructbase_t self) -> std::string

        std::string
        jstructbase_t::showstr() 
        """
        return _oalib.jstructbase_t_showstr(self)


    def allzero(self):
        """
        allzero(jstructbase_t self) -> int

        int
        jstructbase_t::allzero()

        return 1 if all vals are zero 
        """
        return _oalib.jstructbase_t_allzero(self)

    __swig_destroy__ = _oalib.delete_jstructbase_t
    __del__ = lambda self: None
jstructbase_t_swigregister = _oalib.jstructbase_t_swigregister
jstructbase_t_swigregister(jstructbase_t)

class symmdata(object):
    """


    structure containing data related to symmetries of arrays

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rowvalue = _swig_property(_oalib.symmdata_rowvalue_get, _oalib.symmdata_rowvalue_set)
    orig = _swig_property(_oalib.symmdata_orig_get, _oalib.symmdata_orig_set)
    ft = _swig_property(_oalib.symmdata_ft_get, _oalib.symmdata_ft_set)

    def __init__(self, al, minlen=1):
        """
        __init__(symmdata self, array_link al, int minlen=1) -> symmdata
        __init__(symmdata self, array_link al) -> symmdata

        symmdata::symmdata(const
        array_link &al, int minlen=1) 
        """
        this = _oalib.new_symmdata(al, minlen)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, verbose=1):
        """
        show(symmdata self, int verbose=1)
        show(symmdata self)

        void symmdata::show(int
        verbose=1) const 
        """
        return _oalib.symmdata_show(self, verbose)


    def checkIdx(self, col=-1):
        """
        checkIdx(symmdata self, int col=-1) -> intVector
        checkIdx(symmdata self) -> intVector

        std::vector<int>
        symmdata::checkIdx(int col=-1) const

        list with indices set to check for symmetry reductions 
        """
        return _oalib.symmdata_checkIdx(self, col)

    __swig_destroy__ = _oalib.delete_symmdata
    __del__ = lambda self: None
symmdata_swigregister = _oalib.symmdata_swigregister
symmdata_swigregister(symmdata)

class jstruct_t(object):
    """


    struct to hold data of an array, e.g. J-characteristic, rank

    See papers: Minimum G2-aberration properties of two-level foldover
    designs, Butler, 2004 Design Selection and Classification for Hadamard
    Matrices Using Generalized Minimum Aberration Criteria, Deng and Tang

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    N = _swig_property(_oalib.jstruct_t_N_get, _oalib.jstruct_t_N_set)
    k = _swig_property(_oalib.jstruct_t_k_get, _oalib.jstruct_t_k_set)
    jj = _swig_property(_oalib.jstruct_t_jj_get, _oalib.jstruct_t_jj_set)
    nc = _swig_property(_oalib.jstruct_t_nc_get, _oalib.jstruct_t_nc_set)
    values = _swig_property(_oalib.jstruct_t_values_get, _oalib.jstruct_t_values_set)
    A = _swig_property(_oalib.jstruct_t_A_get, _oalib.jstruct_t_A_set)

    def __init__(self, *args):
        """
        __init__(jstruct_t self) -> jstruct_t
        __init__(jstruct_t self, array_link al, int jj=4) -> jstruct_t
        __init__(jstruct_t self, array_link al) -> jstruct_t
        __init__(jstruct_t self, int const N, int const K, int const jj=4) -> jstruct_t
        __init__(jstruct_t self, int const N, int const K) -> jstruct_t
        __init__(jstruct_t self, jstruct_t js) -> jstruct_t

        jstruct_t::jstruct_t(const array_link &al, int jj=4) 
        """
        this = _oalib.new_jstruct_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_jstruct_t
    __del__ = lambda self: None

    def maxJ(self):
        """
        maxJ(jstruct_t self) -> int

        int jstruct_t::maxJ() const

        calculate maximum J value 
        """
        return _oalib.jstruct_t_maxJ(self)


    def Fval(self, strength=3):
        """
        Fval(jstruct_t self, int strength=3) -> intVector
        Fval(jstruct_t self) -> intVector

        std::vector< int >
        jstruct_t::Fval(int strength=3) const

        calculate possible values in F vector 
        """
        return _oalib.jstruct_t_Fval(self, strength)


    def calculateF(self, strength=3):
        """
        calculateF(jstruct_t self, int strength=3) -> intVector
        calculateF(jstruct_t self) -> intVector

        std::vector< int >
        jstruct_t::calculateF(int strength=3) const

        calculate histogram of J values for a 2-level array 
        """
        return _oalib.jstruct_t_calculateF(self, strength)


    def calculateAberration(self):
        """
        calculateAberration(jstruct_t self)

        void
        jstruct_t::calculateAberration() 
        """
        return _oalib.jstruct_t_calculateAberration(self)


    def show(self):
        """
        show(jstruct_t self)

        void jstruct_t::show()

        Show contents of structure. 
        """
        return _oalib.jstruct_t_show(self)


    def showdata(self):
        """
        showdata(jstruct_t self)

        void
        jstruct_t::showdata() 
        """
        return _oalib.jstruct_t_showdata(self)


    def showstr(self):
        """
        showstr(jstruct_t self) -> std::string

        std::string
        jstruct_t::showstr() 
        """
        return _oalib.jstruct_t_showstr(self)


    def allzero(self):
        """
        allzero(jstruct_t self) -> int

        int jstruct_t::allzero()

        return 1 if all vals are zero 
        """
        return _oalib.jstruct_t_allzero(self)


    def __repr__(self):
        """__repr__(jstruct_t self) -> std::string"""
        return _oalib.jstruct_t___repr__(self)

jstruct_t_swigregister = _oalib.jstruct_t_swigregister
jstruct_t_swigregister(jstruct_t)

class jstructconference_t(jstructbase_t):
    """
    C++ includes: arraytools.h

    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(jstructconference_t self, int N, int jj=4) -> jstructconference_t
        __init__(jstructconference_t self, int N) -> jstructconference_t
        __init__(jstructconference_t self, array_link al, int jj=4) -> jstructconference_t
        __init__(jstructconference_t self, array_link al) -> jstructconference_t

        jstructconference_t::jstructconference_t(const array_link &al, int
        jj=4) 
        """
        this = _oalib.new_jstructconference_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_jstructconference_t
    __del__ = lambda self: None
jstructconference_t_swigregister = _oalib.jstructconference_t_swigregister
jstructconference_t_swigregister(jstructconference_t)


def create_root(*args):
    """
    create_root(array_t * array, arraydata_t ad)
    create_root(arraydata_t ad, arraylist_t solutions)
    """
    return _oalib.create_root(*args)

def array_cmp(A, B, r, c):
    """array_cmp(carray_p A, carray_p B, rowindex_t const r, colindex_t const c) -> int"""
    return _oalib.array_cmp(A, B, r, c)

def fastJupdateValue(N, tmpval):
    """fastJupdateValue(rowindex_t N, carray_t * tmpval) -> int"""
    return _oalib.fastJupdateValue(N, tmpval)

def fastJupdate(array, N, J, pp, tmp):
    """fastJupdate(array_t const * array, rowindex_t N, int const J, colindex_t const * pp, array_t * tmp)"""
    return _oalib.fastJupdate(array, N, J, pp, tmp)

def jvalue(ar, J, pp):
    """jvalue(array_link ar, int const J, int const * pp) -> int"""
    return _oalib.jvalue(ar, J, pp)

def jvaluefast(array, N, J, pp):
    """jvaluefast(array_t const * array, rowindex_t N, int const J, colindex_t const * pp) -> int"""
    return _oalib.jvaluefast(array, N, J, pp)

def analyseArrays(arraylist, verbose, jj=4):
    """
    analyseArrays(arraylist_t arraylist, int const verbose, int const jj=4) -> jstructArray
    analyseArrays(arraylist_t arraylist, int const verbose) -> jstructArray
    """
    return _oalib.analyseArrays(arraylist, verbose, jj)
class array_transformation_t(object):
    """


    Contains a transformation of an array.

    Contains an array transformation. The transformation consists of
    column, row and level permutations. The level and column permutations
    are not commutative (since the level permutations are tied to a
    particular column). We apply the column permutations first.

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    rperm = _swig_property(_oalib.array_transformation_t_rperm_get, _oalib.array_transformation_t_rperm_set)
    cperm = _swig_property(_oalib.array_transformation_t_cperm_get, _oalib.array_transformation_t_cperm_set)
    lperms = _swig_property(_oalib.array_transformation_t_lperms_get, _oalib.array_transformation_t_lperms_set)
    ad = _swig_property(_oalib.array_transformation_t_ad_get, _oalib.array_transformation_t_ad_set)

    def __init__(self, *args):
        """
        __init__(array_transformation_t self, arraydata_t ad) -> array_transformation_t
        __init__(array_transformation_t self, arraydata_t ad) -> array_transformation_t
        __init__(array_transformation_t self) -> array_transformation_t
        __init__(array_transformation_t self, array_transformation_t at) -> array_transformation_t

        array_transformation_t::array_transformation_t(const
        array_transformation_t &at)

        default constructor 
        """
        this = _oalib.new_array_transformation_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_array_transformation_t
    __del__ = lambda self: None

    def isIdentity(self):
        """
        isIdentity(array_transformation_t self) -> bool

        bool
        array_transformation_t::isIdentity() const

        return true if the transformation is equal to the identity 
        """
        return _oalib.array_transformation_t_isIdentity(self)


    def inverse(self):
        """
        inverse(array_transformation_t self) -> array_transformation_t

        array_transformation_t array_transformation_t::inverse() const

        return the inverse transformation 
        """
        return _oalib.array_transformation_t_inverse(self)


    def reset(self):
        """
        reset(array_transformation_t self)

        void
        array_transformation_t::reset()

        return the transformation to the identity transformation 
        """
        return _oalib.array_transformation_t_reset(self)


    def randomize(self):
        """
        randomize(array_transformation_t self)

        void
        array_transformation_t::randomize()

        initialize to a random transformation 
        """
        return _oalib.array_transformation_t_randomize(self)


    def randomizecolperm(self):
        """
        randomizecolperm(array_transformation_t self)

        void
        array_transformation_t::randomizecolperm()

        initialize with a random column permutation 
        """
        return _oalib.array_transformation_t_randomizecolperm(self)


    def randomizerowperm(self):
        """
        randomizerowperm(array_transformation_t self)

        void
        array_transformation_t::randomizerowperm()

        initialize with a random row permutation 
        """
        return _oalib.array_transformation_t_randomizerowperm(self)


    def applygeneric(self, al):
        """
        applygeneric(array_transformation_t self, array_link al) -> array_link

        array_link array_transformation_t::applygeneric(const array_link &al)
        const

        apply transformation to an array_link object 
        """
        return _oalib.array_transformation_t_applygeneric(self, al)


    def __eq__(self, t2):
        """__eq__(array_transformation_t self, array_transformation_t t2) -> int"""
        return _oalib.array_transformation_t___eq__(self, t2)


    def __mul__(self, b):
        """__mul__(array_transformation_t self, array_transformation_t b) -> array_transformation_t"""
        return _oalib.array_transformation_t___mul__(self, b)


    def apply(self, *args):
        """
        apply(array_transformation_t self, array_link al) -> array_link
        apply(array_transformation_t self, array_t * sourcetarget)
        apply(array_transformation_t self, array_t const * source, array_t * target)

        void
        array_transformation_t::apply(const array_t *source, array_t *target)
        const

        apply transformation to an array 
        """
        return _oalib.array_transformation_t_apply(self, *args)


    def print_transformed(self, source):
        """
        print_transformed(array_transformation_t self, carray_t * source)

        void array_transformation_t::print_transformed(carray_t *source) const

        apply transformation and show resulting array 
        """
        return _oalib.array_transformation_t_print_transformed(self, source)


    def show(self, *args):
        """
        show(array_transformation_t self)
        show(array_transformation_t self, std::ostream & out)

        void
        array_transformation_t::show(std::ostream &out) const 
        """
        return _oalib.array_transformation_t_show(self, *args)


    def rowperm(self):
        """
        rowperm(array_transformation_t self) -> intVector

        std::vector<
        int > array_transformation_t::rowperm() const 
        """
        return _oalib.array_transformation_t_rowperm(self)


    def colperm(self):
        """
        colperm(array_transformation_t self) -> intVector

        std::vector<
        int > array_transformation_t::colperm() const

        return the row permutation of the transformation 
        """
        return _oalib.array_transformation_t_colperm(self)


    def lvlperm(self, c):
        """
        lvlperm(array_transformation_t self, int c) -> intVector

        std::vector<
        int > array_transformation_t::lvlperm(int c) const

        return the column permutation of the transformation 
        """
        return _oalib.array_transformation_t_lvlperm(self, c)


    def setrowperm(self, rp):
        """
        setrowperm(array_transformation_t self, intVector rp)

        void
        array_transformation_t::setrowperm(std::vector< int > rp)

        return the level permutations of the transformation 
        """
        return _oalib.array_transformation_t_setrowperm(self, rp)


    def setcolperm(self, colperm):
        """
        setcolperm(array_transformation_t self, intVector colperm)

        void
        array_transformation_t::setcolperm(std::vector< int > colperm) 
        """
        return _oalib.array_transformation_t_setcolperm(self, colperm)


    def setlevelperm(self, colindex, lvlperm):
        """
        setlevelperm(array_transformation_t self, int colindex, intVector lvlperm)

        void
        array_transformation_t::setlevelperm(int colindex, std::vector< int >
        lvlperm) 
        """
        return _oalib.array_transformation_t_setlevelperm(self, colindex, lvlperm)


    def __repr__(self):
        """__repr__(array_transformation_t self) -> std::string"""
        return _oalib.array_transformation_t___repr__(self)

array_transformation_t_swigregister = _oalib.array_transformation_t_swigregister
array_transformation_t_swigregister(array_transformation_t)

class conference_transformation_t(object):
    """


    Contains a transformation of a conference matrix.

    Contains an array transformation. The transformation consists of
    column permutations, row permutations and sign switches for both the
    rows and columns.

    The sign switches and the permutations are not commutative. We apply
    the permutations first and then the sign flips.

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rperm = _swig_property(_oalib.conference_transformation_t_rperm_get, _oalib.conference_transformation_t_rperm_set)
    cperm = _swig_property(_oalib.conference_transformation_t_cperm_get, _oalib.conference_transformation_t_cperm_set)
    cswitch = _swig_property(_oalib.conference_transformation_t_cswitch_get, _oalib.conference_transformation_t_cswitch_set)
    rswitch = _swig_property(_oalib.conference_transformation_t_rswitch_get, _oalib.conference_transformation_t_rswitch_set)
    nrows = _swig_property(_oalib.conference_transformation_t_nrows_get, _oalib.conference_transformation_t_nrows_set)
    ncols = _swig_property(_oalib.conference_transformation_t_ncols_get, _oalib.conference_transformation_t_ncols_set)

    def __init__(self, *args):
        """
        __init__(conference_transformation_t self) -> conference_transformation_t
        __init__(conference_transformation_t self, int nrows, int ncols) -> conference_transformation_t
        __init__(conference_transformation_t self, array_link al) -> conference_transformation_t
        __init__(conference_transformation_t self, conference_transformation_t T) -> conference_transformation_t

        conference_transformation_t::conference_transformation_t(const
        conference_transformation_t &T) 
        """
        this = _oalib.new_conference_transformation_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self, verbose=1):
        """
        show(conference_transformation_t self, int verbose=1)
        show(conference_transformation_t self)

        void
        conference_transformation_t::show(int verbose=1) const

        show the array transformation 
        """
        return _oalib.conference_transformation_t_show(self, verbose)


    def isIdentity(self):
        """
        isIdentity(conference_transformation_t self) -> bool

        bool
        conference_transformation_t::isIdentity() const

        return true if the transformation is equal to the identity 
        """
        return _oalib.conference_transformation_t_isIdentity(self)


    def inverse(self):
        """
        inverse(conference_transformation_t self) -> conference_transformation_t

        conference_transformation_t conference_transformation_t::inverse()
        const

        return the inverse transformation 
        """
        return _oalib.conference_transformation_t_inverse(self)


    def reset(self):
        """
        reset(conference_transformation_t self)

        void
        conference_transformation_t::reset()

        return the transformation to the identity transformation 
        """
        return _oalib.conference_transformation_t_reset(self)


    def randomize(self):
        """
        randomize(conference_transformation_t self)

        void
        conference_transformation_t::randomize()

        initialize to a random transformation 
        """
        return _oalib.conference_transformation_t_randomize(self)


    def randomizecolperm(self):
        """
        randomizecolperm(conference_transformation_t self)

        void conference_transformation_t::randomizecolperm()

        initialize with a random column permutation 
        """
        return _oalib.conference_transformation_t_randomizecolperm(self)


    def randomizerowperm(self):
        """
        randomizerowperm(conference_transformation_t self)

        void conference_transformation_t::randomizerowperm()

        initialize with a random row permutation 
        """
        return _oalib.conference_transformation_t_randomizerowperm(self)


    def randomizecolflips(self):
        """
        randomizecolflips(conference_transformation_t self)

        void conference_transformation_t::randomizecolflips()

        initialize with random col switches 
        """
        return _oalib.conference_transformation_t_randomizecolflips(self)


    def randomizerowflips(self):
        """
        randomizerowflips(conference_transformation_t self)

        void conference_transformation_t::randomizerowflips()

        initialize with random row switches 
        """
        return _oalib.conference_transformation_t_randomizerowflips(self)


    def apply(self, al):
        """
        apply(conference_transformation_t self, array_link al) -> array_link

        array_link
        conference_transformation_t::apply(const array_link &al) const

        apply transformation to an array_link object 
        """
        return _oalib.conference_transformation_t_apply(self, al)


    def __eq__(self, rhs):
        """__eq__(conference_transformation_t self, conference_transformation_t rhs) -> int"""
        return _oalib.conference_transformation_t___eq__(self, rhs)


    def __mul__(self, rhs):
        """__mul__(conference_transformation_t self, conference_transformation_t rhs) -> conference_transformation_t"""
        return _oalib.conference_transformation_t___mul__(self, rhs)


    def setrowperm(self, rp):
        """
        setrowperm(conference_transformation_t self, intVector rp)

        void
        conference_transformation_t::setrowperm(std::vector< int >rp) 
        """
        return _oalib.conference_transformation_t_setrowperm(self, rp)


    def setcolperm(self, cp):
        """
        setcolperm(conference_transformation_t self, intVector cp)

        void
        conference_transformation_t::setcolperm(std::vector< int >cp) 
        """
        return _oalib.conference_transformation_t_setcolperm(self, cp)

    __swig_destroy__ = _oalib.delete_conference_transformation_t
    __del__ = lambda self: None
conference_transformation_t_swigregister = _oalib.conference_transformation_t_swigregister
conference_transformation_t_swigregister(conference_transformation_t)


def showArrayList(lst):
    """showArrayList(arraylist_t lst)"""
    return _oalib.showArrayList(lst)

_oalib.ATEXT_swigconstant(_oalib)
ATEXT = _oalib.ATEXT

_oalib.ALATEX_swigconstant(_oalib)
ALATEX = _oalib.ALATEX

_oalib.ABINARY_swigconstant(_oalib)
ABINARY = _oalib.ABINARY

_oalib.ABINARY_DIFF_swigconstant(_oalib)
ABINARY_DIFF = _oalib.ABINARY_DIFF

_oalib.ABINARY_DIFFZERO_swigconstant(_oalib)
ABINARY_DIFFZERO = _oalib.ABINARY_DIFFZERO

_oalib.AERROR_swigconstant(_oalib)
AERROR = _oalib.AERROR

_oalib.A_AUTOMATIC_swigconstant(_oalib)
A_AUTOMATIC = _oalib.A_AUTOMATIC

_oalib.A_AUTOMATIC_BINARY_swigconstant(_oalib)
A_AUTOMATIC_BINARY = _oalib.A_AUTOMATIC_BINARY

_oalib.READ_swigconstant(_oalib)
READ = _oalib.READ

_oalib.WRITE_swigconstant(_oalib)
WRITE = _oalib.WRITE

_oalib.READWRITE_swigconstant(_oalib)
READWRITE = _oalib.READWRITE
class arrayfile_t(object):
    """


    Structure for reading or writing a file with arrays.

    The format of array files is described in the file FORMAT.txt

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    filename = _swig_property(_oalib.arrayfile_t_filename_get, _oalib.arrayfile_t_filename_set)
    iscompressed = _swig_property(_oalib.arrayfile_t_iscompressed_get, _oalib.arrayfile_t_iscompressed_set)
    nrows = _swig_property(_oalib.arrayfile_t_nrows_get, _oalib.arrayfile_t_nrows_set)
    ncols = _swig_property(_oalib.arrayfile_t_ncols_get, _oalib.arrayfile_t_ncols_set)
    nbits = _swig_property(_oalib.arrayfile_t_nbits_get, _oalib.arrayfile_t_nbits_set)
    mode = _swig_property(_oalib.arrayfile_t_mode_get, _oalib.arrayfile_t_mode_set)
    rwmode = _swig_property(_oalib.arrayfile_t_rwmode_get, _oalib.arrayfile_t_rwmode_set)
    narrays = _swig_property(_oalib.arrayfile_t_narrays_get, _oalib.arrayfile_t_narrays_set)
    narraycounter = _swig_property(_oalib.arrayfile_t_narraycounter_get, _oalib.arrayfile_t_narraycounter_set)
    NARRAYS_MAX = _oalib.arrayfile_t_NARRAYS_MAX

    def __init__(self, *args):
        """
        __init__(arrayfile::arrayfile_t self) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname, int verbose=1) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1, arrayfile::arrayfilemode_t m, int nb=8) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1, arrayfile::arrayfilemode_t m) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1) -> arrayfile_t
        __init__(arrayfile::arrayfile_t self, std::string const fname, int nrows, int ncols) -> arrayfile_t

        arrayfile::arrayfile_t::arrayfile_t(const std::string fname, int
        nrows, int ncols, int narrays=-1, arrayfilemode_t m=ATEXT, int nb=8)

        open new array file for writing 
        """
        this = _oalib.new_arrayfile_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_arrayfile_t
    __del__ = lambda self: None

    def createfile(self, *args):
        """
        createfile(arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1, arrayfile::arrayfilemode_t m, int nb=8)
        createfile(arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1, arrayfile::arrayfilemode_t m)
        createfile(arrayfile_t self, std::string const fname, int nrows, int ncols, int narrays=-1)
        createfile(arrayfile_t self, std::string const fname, int nrows, int ncols)

        void
        arrayfile::arrayfile_t::createfile(const std::string fname, int nrows,
        int ncols, int narrays=-1, arrayfilemode_t m=ATEXT, int nb=8)

        close current file and open a new file for writing 
        """
        return _oalib.arrayfile_t_createfile(self, *args)


    def closefile(self):
        """
        closefile(arrayfile_t self)

        void
        arrayfile::arrayfile_t::closefile()

        close the array file 
        """
        return _oalib.arrayfile_t_closefile(self)


    def isopen(self):
        """
        isopen(arrayfile_t self) -> int

        int
        arrayfile::arrayfile_t::isopen() const

        return true if file is open 
        """
        return _oalib.arrayfile_t_isopen(self)


    def seek(self, pos):
        """
        seek(arrayfile_t self, int pos) -> int

        int
        arrayfile::arrayfile_t::seek(int pos)

        seek to specified array position 
        """
        return _oalib.arrayfile_t_seek(self, pos)


    def readnext(self):
        """
        readnext(arrayfile_t self) -> array_link

        array_link
        arrayfile::arrayfile_t::readnext()

        read next array from the file 
        """
        return _oalib.arrayfile_t_readnext(self)


    def readarrays(self, *args):
        """
        readarrays(arrayfile_t self, int nmax, int verbose=1) -> arraylist_t
        readarrays(arrayfile_t self, int nmax) -> arraylist_t
        readarrays(arrayfile_t self) -> arraylist_t

        arraylist_t arrayfile::arrayfile_t::readarrays(int nmax=NARRAYS_MAX,
        int verbose=1)

        read set of array from the file 
        """
        return _oalib.arrayfile_t_readarrays(self, *args)


    def flush(self):
        """
        flush(arrayfile_t self)

        void
        arrayfile::arrayfile_t::flush()

        flush any open file pointer 
        """
        return _oalib.arrayfile_t_flush(self)


    def isbinary(self):
        """
        isbinary(arrayfile_t self) -> bool

        bool
        arrayfile::arrayfile_t::isbinary() const

        return true if the file has binary format 
        """
        return _oalib.arrayfile_t_isbinary(self)


    def append_arrays(self, arrays, startidx=-1):
        """
        append_arrays(arrayfile_t self, arraylist_t arrays, int startidx=-1) -> int
        append_arrays(arrayfile_t self, arraylist_t arrays) -> int

        int
        arrayfile::arrayfile_t::append_arrays(const arraylist_t &arrays, int
        startidx=-1)

        append list of arrays to the file 
        """
        return _oalib.arrayfile_t_append_arrays(self, arrays, startidx)


    def append_array(self, a, specialindex=-1):
        """
        append_array(arrayfile_t self, array_link a, int specialindex=-1)
        append_array(arrayfile_t self, array_link a)

        void
        arrayfile::arrayfile_t::append_array(const array_link &a, int
        specialindex=-1)

        append a single array to the file 
        """
        return _oalib.arrayfile_t_append_array(self, a, specialindex)


    def swigcheck(self):
        """
        swigcheck(arrayfile_t self) -> int

        int
        arrayfile::arrayfile_t::swigcheck() const 
        """
        return _oalib.arrayfile_t_swigcheck(self)


    def showstr(self):
        """
        showstr(arrayfile_t self) -> std::string

        std::string
        arrayfile::arrayfile_t::showstr() const 
        """
        return _oalib.arrayfile_t_showstr(self)


    def pos(self):
        """
        pos(arrayfile_t self) -> size_t

        size_t
        arrayfile::arrayfile_t::pos() const 
        """
        return _oalib.arrayfile_t_pos(self)


    def hasrandomaccess(self):
        """
        hasrandomaccess(arrayfile_t self) -> bool

        bool
        arrayfile::arrayfile_t::hasrandomaccess() const

        return true of the file format has random access mode 
        """
        return _oalib.arrayfile_t_hasrandomaccess(self)

    nfid = _swig_property(_oalib.arrayfile_t_nfid_get, _oalib.arrayfile_t_nfid_set)
    gzfid = _swig_property(_oalib.arrayfile_t_gzfid_get, _oalib.arrayfile_t_gzfid_set)
    verbose = _swig_property(_oalib.arrayfile_t_verbose_get, _oalib.arrayfile_t_verbose_set)

    def updatenumbers(self):
        """
        updatenumbers(arrayfile_t self)

        void
        arrayfile::arrayfile_t::updatenumbers() 
        """
        return _oalib.arrayfile_t_updatenumbers(self)


    def read_array(self, *args):
        """
        read_array(arrayfile_t self, array_link a) -> int
        read_array(arrayfile_t self, array_t * array, int const nrows, int const ncols) -> int

        int
        arrayfile::arrayfile_t::read_array(array_t *array, const int nrows,
        const int ncols)

        read array and return index 
        """
        return _oalib.arrayfile_t_read_array(self, *args)


    def finisharrayfile(self):
        """
        finisharrayfile(arrayfile_t self)

        void
        arrayfile::arrayfile_t::finisharrayfile() 
        """
        return _oalib.arrayfile_t_finisharrayfile(self)


    def setVerbose(self, v):
        """
        setVerbose(arrayfile_t self, int v)

        void
        arrayfile::arrayfile_t::setVerbose(int v) 
        """
        return _oalib.arrayfile_t_setVerbose(self, v)


    def getnbits(self):
        """
        getnbits(arrayfile_t self) -> int

        int
        arrayfile::arrayfile_t::getnbits() 
        """
        return _oalib.arrayfile_t_getnbits(self)


    def parseModeString(format):
        """parseModeString(std::string const format) -> arrayfile::arrayfilemode_t"""
        return _oalib.arrayfile_t_parseModeString(format)

    parseModeString = staticmethod(parseModeString)

    def arrayNbits(*args):
        """
        arrayNbits(arraydata_t ad) -> int
        arrayNbits(array_link A) -> int
        """
        return _oalib.arrayfile_t_arrayNbits(*args)

    arrayNbits = staticmethod(arrayNbits)

    def __repr__(self):
        """__repr__(arrayfile_t self) -> std::string"""
        return _oalib.arrayfile_t___repr__(self)

arrayfile_t_swigregister = _oalib.arrayfile_t_swigregister
arrayfile_t_swigregister(arrayfile_t)

def arrayfile_t_parseModeString(format):
    """arrayfile_t_parseModeString(std::string const format) -> arrayfile::arrayfilemode_t"""
    return _oalib.arrayfile_t_parseModeString(format)

def arrayfile_t_arrayNbits(*args):
    """
    arrayNbits(arraydata_t ad) -> int
    arrayfile_t_arrayNbits(array_link A) -> int
    """
    return _oalib.arrayfile_t_arrayNbits(*args)


def nArrays(fname):
    """nArrays(char const * fname) -> long"""
    return _oalib.nArrays(fname)

def arrayfileinfo(fname, n, nr, nc):
    """arrayfileinfo(char const * fname, int & n, int & nr, int & nc)"""
    return _oalib.arrayfileinfo(fname, n, nr, nc)

def readarrayfile(*args):
    """
    readarrayfile(char const * fname, int verbose=0, int * setcols=None) -> arraylist_t
    readarrayfile(char const * fname, int verbose=0) -> arraylist_t
    readarrayfile(char const * fname) -> arraylist_t
    readarrayfile(char const * fname, arraylist_t arraylist, int verbose=1, int * setcols=None, rowindex_t * setrows=None, int * setbits=None) -> int
    readarrayfile(char const * fname, arraylist_t arraylist, int verbose=1, int * setcols=None, rowindex_t * setrows=None) -> int
    readarrayfile(char const * fname, arraylist_t arraylist, int verbose=1, int * setcols=None) -> int
    readarrayfile(char const * fname, arraylist_t arraylist, int verbose=1) -> int
    readarrayfile(char const * fname, arraylist_t arraylist) -> int
    """
    return _oalib.readarrayfile(*args)

def writearrayfile(*args):
    """
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode, int nrows, int ncols) -> int
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode, int nrows) -> int
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode) -> int
    writearrayfile(char const * fname, arraylist_t arraylist) -> int
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode, int nrows, int ncols) -> int
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode, int nrows) -> int
    writearrayfile(char const * fname, arraylist_t arraylist, arrayfile::arrayfilemode_t mode) -> int
    writearrayfile(char const * fname, arraylist_t arraylist) -> int
    writearrayfile(char const * fname, array_link al, arrayfile::arrayfilemode_t mode) -> int
    writearrayfile(char const * fname, array_link al) -> int
    """
    return _oalib.writearrayfile(*args)

def appendarrayfile(fname, al):
    """appendarrayfile(char const * fname, array_link al) -> int"""
    return _oalib.appendarrayfile(fname, al)

def create_arrayfile(*args):
    """
    create_arrayfile(char const * fname, int rows, int cols, int narrays, arrayfile::arrayfilemode_t mode, int nbits=8) -> arrayfile_t
    create_arrayfile(char const * fname, int rows, int cols, int narrays, arrayfile::arrayfilemode_t mode) -> arrayfile_t
    create_arrayfile(char const * fname, int rows, int cols, int narrays) -> arrayfile_t
    """
    return _oalib.create_arrayfile(*args)

def save_arrays(*args):
    """
    save_arrays(arraylist_t solutions, arraydata_t ad, int const n_arrays, int const n_procs, char const * resultprefix, arrayfile::arrayfilemode_t mode) -> int
    save_arrays(arraylist_t solutions, arraydata_t ad, int const n_arrays, int const n_procs, char const * resultprefix) -> int
    """
    return _oalib.save_arrays(*args)

def selectArrays(*args):
    """
    selectArrays(std::string const filename, intVector idx, arraylist_t fl, int verbose=0)
    selectArrays(std::string const filename, intVector idx, arraylist_t fl)
    selectArrays(std::string filename, int ii) -> array_link
    selectArrays(arraylist_t al, intVector idx) -> arraylist_t
    selectArrays(arraylist_t al, longVector idx) -> arraylist_t
    selectArrays(arraylist_t al, intVector idx, arraylist_t fl)
    selectArrays(arraylist_t al, longVector idx, arraylist_t fl)
    """
    return _oalib.selectArrays(*args)

def appendArrays(al, dst):
    """appendArrays(arraylist_t al, arraylist_t dst)"""
    return _oalib.appendArrays(al, dst)
class arraywriter_t(object):
    """


    structure to write arrays to disk, thread safe

    C++ includes: arraytools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    afiles = _swig_property(_oalib.arraywriter_t_afiles_get, _oalib.arraywriter_t_afiles_set)
    writearrays = _swig_property(_oalib.arraywriter_t_writearrays_get, _oalib.arraywriter_t_writearrays_set)
    nwritten = _swig_property(_oalib.arraywriter_t_nwritten_get, _oalib.arraywriter_t_nwritten_set)
    verbose = _swig_property(_oalib.arraywriter_t_verbose_get, _oalib.arraywriter_t_verbose_set)

    def __init__(self):
        """
        __init__(arraywriter_t self) -> arraywriter_t

        arraywriter_t::arraywriter_t()

        verbosity level 
        """
        this = _oalib.new_arraywriter_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_arraywriter_t
    __del__ = lambda self: None

    def flush(self):
        """
        flush(arraywriter_t self)

        void
        arraywriter_t::flush() 
        """
        return _oalib.arraywriter_t_flush(self)


    def writeArray(self, *args):
        """
        writeArray(arraywriter_t self, array_link A)
        writeArray(arraywriter_t self, arraylist_t lst)

        void
        arraywriter_t::writeArray(const arraylist_t &lst) 
        """
        return _oalib.arraywriter_t_writeArray(self, *args)


    def initArrayFiles(self, *args):
        """
        initArrayFiles(arraywriter_t self, arraydata_t ad, int kstart, std::string const prefix, arrayfile::arrayfilemode_t mode)
        initArrayFiles(arraywriter_t self, arraydata_t ad, int kstart, std::string const prefix)

        void
        arraywriter_t::initArrayFiles(const arraydata_t &ad, int kstart, const
        std::string prefix, arrayfilemode_t mode=ABINARY_DIFF) 
        """
        return _oalib.arraywriter_t_initArrayFiles(self, *args)


    def nArraysWritten(self):
        """
        nArraysWritten(arraywriter_t self) -> int

        int
        arraywriter_t::nArraysWritten() const

        return the total number arrays written to disk 
        """
        return _oalib.arraywriter_t_nArraysWritten(self)


    def closeafiles(self):
        """
        closeafiles(arraywriter_t self)

        void
        arraywriter_t::closeafiles() 
        """
        return _oalib.arraywriter_t_closeafiles(self)

arraywriter_t_swigregister = _oalib.arraywriter_t_swigregister
arraywriter_t_swigregister(arraywriter_t)
NRAUTO = cvar.NRAUTO


def readbinheader(fid, nr, nc):
    """readbinheader(FILE * fid, int & nr, int & nc) -> bool"""
    return _oalib.readbinheader(fid, nr, nc)

def vectorvector2binfile(fname, vals, writeheader, na):
    """vectorvector2binfile(std::string const fname, vector_vector_double vals, int writeheader, int na)"""
    return _oalib.vectorvector2binfile(fname, vals, writeheader, na)

def array2eigenX2(al):
    """array2eigenX2(array_link al) -> MatrixFloat"""
    return _oalib.array2eigenX2(al)

def array2eigenX1(al, intercept=1):
    """
    array2eigenX1(array_link al, int intercept=1) -> MatrixFloat
    array2eigenX1(array_link al) -> MatrixFloat
    """
    return _oalib.array2eigenX1(al, intercept)

def array2eigenModelMatrix(al):
    """array2eigenModelMatrix(array_link al) -> MatrixFloat"""
    return _oalib.array2eigenModelMatrix(al)

def array2eigenME(al, verbose=1):
    """
    array2eigenME(array_link al, int verbose=1) -> MatrixFloat
    array2eigenME(array_link al) -> MatrixFloat
    """
    return _oalib.array2eigenME(al, verbose)

def array2eigenModelMatrixMixed(al, verbose=1):
    """
    array2eigenModelMatrixMixed(array_link al, int verbose=1) -> std::pair< MatrixFloat,MatrixFloat >
    array2eigenModelMatrixMixed(array_link al) -> std::pair< MatrixFloat,MatrixFloat >
    """
    return _oalib.array2eigenModelMatrixMixed(al, verbose)

def arrayInFile(al, afile, verbose=1):
    """
    arrayInFile(array_link al, char const * afile, int verbose=1) -> int
    arrayInFile(array_link al, char const * afile) -> int
    """
    return _oalib.arrayInFile(al, afile, verbose)

def arrayInList(al, ll, verbose=1):
    """
    arrayInList(array_link al, arraylist_t ll, int verbose=1) -> int
    arrayInList(array_link al, arraylist_t ll) -> int
    """
    return _oalib.arrayInList(al, ll, verbose)

def base_name(path):
    """
    base_name(std::string const & path) -> std::string

    std::string base_name(std::string
    const &path) 
    """
    return _oalib.base_name(path)

def printfd_handler(file, func, line, message):
    """
    printfd_handler(char const * file, char const * func, int line, char const * message)

    void printfd_handler(const
    char *file, const char *func, int line, const char *message,...) 
    """
    return _oalib.printfd_handler(file, func, line, message)

_oalib.LOGERROR_swigconstant(_oalib)
LOGERROR = _oalib.LOGERROR

_oalib.SYSTEM_swigconstant(_oalib)
SYSTEM = _oalib.SYSTEM

_oalib.QUIET_swigconstant(_oalib)
QUIET = _oalib.QUIET

_oalib.NORMAL_swigconstant(_oalib)
NORMAL = _oalib.NORMAL

_oalib.DEBUG_swigconstant(_oalib)
DEBUG = _oalib.DEBUG

_oalib.EXTRADEBUG_swigconstant(_oalib)
EXTRADEBUG = _oalib.EXTRADEBUG

def log_print(level, message):
    """
    log_print(int const level, char const * message) -> int

    int log_print(const int level,
    const char *message,...) 
    """
    return _oalib.log_print(level, message)

def getloglevel():
    """
    getloglevel() -> int

    int getloglevel() 
    """
    return _oalib.getloglevel()

def setloglevel(n):
    """
    setloglevel(int n)

    void setloglevel(int n) 
    """
    return _oalib.setloglevel(n)

def checkloglevel(l):
    """
    checkloglevel(int l) -> bool

    bool checkloglevel(int l) 
    """
    return _oalib.checkloglevel(l)

def system_uname():
    """
    system_uname() -> std::string

    std::string system_uname() 
    """
    return _oalib.system_uname()

def mycheck_handler(file, func, line, condition, message):
    """
    mycheck_handler(char const * file, char const * func, int line, int condition, char const * message)

    void mycheck_handler(const
    char *file, const char *func, int line, int condition, const char
    *message,...) 
    """
    return _oalib.mycheck_handler(file, func, line, condition, message)

def myassert(condition, str=None):
    """
    myassert(int condition, char const * str=None)
    myassert(int condition)

    void myassert(int condition, const
    char *str=0) 
    """
    return _oalib.myassert(condition, str)

def myassertdebug2(condition, str):
    """
    myassertdebug2(int condition, char const * str)

    void myassertdebug2(int
    condition, const char *str) 
    """
    return _oalib.myassertdebug2(condition, str)

def cprintf(check, message):
    """
    cprintf(int check, char const * message) -> int

    int cprintf(int check, const char
    *message,...) 
    """
    return _oalib.cprintf(check, message)

def ff():
    """
    ff()

    void ff()

    flush to stdout 
    """
    return _oalib.ff()

def next_comb_s(comb, k, n):
    """
    next_comb_s(int * comb, int k, int n) -> int

    int next_comb_s(int *comb, int k,
    int n)

    Go to next combination in sequence 
    """
    return _oalib.next_comb_s(comb, k, n)

def print_array(*args):
    """
    print_array(char const * str, array_t const * array, rowindex_t const r, colindex_t const c)
    print_array(array_t const * array, rowindex_t const r, colindex_t const c)
    print_array(array_link A)

    void print_array(const array_link
    &A)

    Print array to stdout. 
    """
    return _oalib.print_array(*args)

def countelements(array, nelements, maxval, elements):
    """
    countelements(carray_t * array, int const nelements, int const maxval, int * elements)

    void countelements(carray_t
    *array, const int nelements, const int maxval, int *elements)

    Counts the number of occurences of each value in an array. 
    """
    return _oalib.countelements(array, nelements, maxval, elements)

def get_time_ms(*args):
    """
    get_time_ms() -> double
    get_time_ms(double t0) -> double

    double get_time_ms(double t0)

    return time difference with milisecond precision 
    """
    return _oalib.get_time_ms(*args)

def trim(*args):
    """
    trim(std::string & str, std::string const & trimChars)
    trim(std::string & str)

    void trim(std::string &str, const
    std::string &trimChars="")

    trim a string by removing the specified characters from the left and
    right 
    """
    return _oalib.trim(*args)

def currenttime():
    """
    currenttime() -> std::string

    std::string currenttime()

    return the current time as a string 
    """
    return _oalib.currenttime()

def oafilestring(*args):
    """
    oafilestring(arraydata_t ad) -> std::string
    oafilestring(rowindex_t rows, colindex_t cols, array_t * s) -> std::string

    std::string
    oafilestring(rowindex_t rows, colindex_t cols, array_t *s)

    return string describing array 
    """
    return _oalib.oafilestring(*args)

def printtime():
    """
    printtime() -> std::string

    std::string printtime() 
    """
    return _oalib.printtime()

def replaceString(subject, search, replace):
    """
    replaceString(std::string subject, std::string const & search, std::string const & replace) -> std::string

    std::string
    replaceString(std::string subject, const std::string &search, const
    std::string &replace)

    replace all occurces of a substring in a string 
    """
    return _oalib.replaceString(subject, search, replace)

def printdoubleasbits(decker):
    """
    printdoubleasbits(double decker)

    void
    printdoubleasbits(double decker)

    print a double value as bits 
    """
    return _oalib.printdoubleasbits(decker)

def splitDir(ii):
    """splitDir(intVector ii) -> std::string"""
    return _oalib.splitDir(ii)

def splitFile(ii):
    """splitFile(intVector ii) -> std::string"""
    return _oalib.splitFile(ii)

def splitTag(ii):
    """splitTag(intVector ii) -> std::string"""
    return _oalib.splitTag(ii)

def detXtX(mymatrix, verbose=1):
    """
    detXtX(Eigen::MatrixXd const & mymatrix, int verbose=1) -> double
    detXtX(Eigen::MatrixXd const & mymatrix) -> double

    double detXtX(const Eigen::MatrixXd
    &mymatrix, int verbose=1)

    calculate determinant of X^T X by using the SVD 
    """
    return _oalib.detXtX(mymatrix, verbose)

def DAEefficiecyWithSVD(x, Deff, vif, Eeff, rank, verbose):
    """
    DAEefficiecyWithSVD(Eigen::MatrixXd const & x, double & Deff, double & vif, double & Eeff, int & rank, int verbose)

    void
    DAEefficiecyWithSVD(const Eigen::MatrixXd &x, double &Deff, double
    &vif, double &Eeff, int &rank, int verbose)

    Calculate D-efficiency and VIF-efficiency and E-efficiency values
    using SVD. 
    """
    return _oalib.DAEefficiecyWithSVD(x, Deff, vif, Eeff, rank, verbose)

def array_rank_D_B(al, ret=None, verbose=0):
    """
    array_rank_D_B(array_link al, doubleVector ret=None, int verbose=0) -> int
    array_rank_D_B(array_link al, doubleVector ret=None) -> int
    array_rank_D_B(array_link al) -> int

    int array_rank_D_B(const
    array_link &al, std::vector< double > *ret=0, int verbose=0)

    Calculate the rank of the second order interaction matrix of an
    orthogonal array, the rank, D-efficiency, VIF-efficiency and
    E-efficiency are appended to the second argument. 
    """
    return _oalib.array_rank_D_B(al, ret, verbose)

def Defficiency(al, verbose=0):
    """
    Defficiency(array_link al, int verbose=0) -> double
    Defficiency(array_link al) -> double

    double Defficiency(const
    array_link &al, int verbose=0)

    Calculate D-efficiency for a 2-level array using symmetric eigenvalue
    decomposition. 
    """
    return _oalib.Defficiency(al, verbose)

def Defficiencies(al, arrayclass, verbose=0, addDs0=0):
    """
    Defficiencies(array_link al, arraydata_t arrayclass, int verbose=0, int addDs0=0) -> doubleVector
    Defficiencies(array_link al, arraydata_t arrayclass, int verbose=0) -> doubleVector
    Defficiencies(array_link al, arraydata_t arrayclass) -> doubleVector

    std::vector< double >
    Defficiencies(const array_link &al, const arraydata_t &arrayclass, int
    verbose=0, int addDs0=0) 
    """
    return _oalib.Defficiencies(al, arrayclass, verbose, addDs0)

def VIFefficiency(al, verbose=0):
    """
    VIFefficiency(array_link al, int verbose=0) -> double
    VIFefficiency(array_link al) -> double

    double VIFefficiency(const
    array_link &al, int verbose=0)

    Calculate VIF-efficiency of matrix. 
    """
    return _oalib.VIFefficiency(al, verbose)

def Aefficiency(al, verbose=0):
    """
    Aefficiency(array_link al, int verbose=0) -> double
    Aefficiency(array_link al) -> double

    double Aefficiency(const
    array_link &al, int verbose=0)

    Calculate A-efficiency of matrix. 
    """
    return _oalib.Aefficiency(al, verbose)

def Eefficiency(al, verbose=0):
    """
    Eefficiency(array_link al, int verbose=0) -> double
    Eefficiency(array_link al) -> double

    double Eefficiency(const
    array_link &al, int verbose=0)

    Calculate E-efficiency of matrix (1 over the VIF-efficiency) 
    """
    return _oalib.Eefficiency(al, verbose)

def Aefficiencies(al, verbose=0):
    """
    Aefficiencies(array_link al, int verbose=0) -> doubleVector
    Aefficiencies(array_link al) -> doubleVector

    std::vector< double >
    Aefficiencies(const array_link &al, int verbose=0)

    calculate various A-efficiencies 
    """
    return _oalib.Aefficiencies(al, verbose)

def projDeff(al, kp, verbose):
    """
    projDeff(array_link al, int kp, int verbose) -> doubleVector

    std::vector< double > projDeff(const
    array_link &al, int kp, int verbose)

    Return the D-efficiencies for the projection designs. 
    """
    return _oalib.projDeff(al, kp, verbose)

def PECsequence(al, verbose=0):
    """
    PECsequence(array_link al, int verbose=0) -> doubleVector
    PECsequence(array_link al) -> doubleVector

    std::vector< double >
    PECsequence(const array_link &al, int verbose=0)

    Return the projection estimation capacity sequence of a design. 
    """
    return _oalib.PECsequence(al, verbose)

def distance_distribution(al):
    """
    distance_distribution(array_link al) -> doubleVector

    std::vector< double >
    distance_distribution(const array_link &al)

    Return the distance distribution of a design. 
    """
    return _oalib.distance_distribution(al)

def Jcharacteristics(al, jj=4, verbose=0):
    """
    Jcharacteristics(array_link al, int jj=4, int verbose=0) -> intVector
    Jcharacteristics(array_link al, int jj=4) -> intVector
    Jcharacteristics(array_link al) -> intVector

    std::vector< int >
    Jcharacteristics(const array_link &al, int jj=4, int verbose=0)

    Calculate J-characteristics of matrix (the values are signed) 
    """
    return _oalib.Jcharacteristics(al, jj, verbose)

def GWLP(al, verbose=0, truncate=1):
    """
    GWLP(array_link al, int verbose=0, int truncate=1) -> doubleVector
    GWLP(array_link al, int verbose=0) -> doubleVector
    GWLP(array_link al) -> doubleVector

    std::vector< double > GWLP(const
    array_link &al, int verbose=0, int truncate=1)

    calculate GWLP (generalized wordlength pattern)

    The method used for calculation is from Xu and Wu (2001),
    "Generalized minimum aberration for asymmetrical fractional factorial
    desings" The non-symmetric arrays see "Algorithmic Construction of
    Efficient Fractional Factorial Designs With Large Run Sizes", Xu 
    """
    return _oalib.GWLP(al, verbose, truncate)

def GWLPmixed(al, verbose=0, truncate=1):
    """
    GWLPmixed(array_link al, int verbose=0, int truncate=1) -> doubleVector
    GWLPmixed(array_link al, int verbose=0) -> doubleVector
    GWLPmixed(array_link al) -> doubleVector

    std::vector< double >
    GWLPmixed(const array_link &al, int verbose=0, int truncate=1) 
    """
    return _oalib.GWLPmixed(al, verbose, truncate)

def projectionGWLPs(al):
    """
    projectionGWLPs(array_link al) -> vector_mvalue_t_double

    std::vector< GWLPvalue >
    projectionGWLPs(const array_link &al)

    calculate delete-one-factor GWLP (generalized wordlength pattern)
    projections 
    """
    return _oalib.projectionGWLPs(al)

def sortGWLP(arg1):
    """
    sortGWLP(vector_mvalue_t_double arg1) -> vector_mvalue_t_double

    std::vector< GWLPvalue >
    sortGWLP(std::vector< GWLPvalue >) 
    """
    return _oalib.sortGWLP(arg1)

def projectionGWLPvalues(al):
    """
    projectionGWLPvalues(array_link al) -> doubleVector

    std::vector< double >
    projectionGWLPvalues(const array_link &al)

    calculate delete-one-factor GWLP (generalized wordlength pattern)
    projection values 
    """
    return _oalib.projectionGWLPvalues(al)

def CL2discrepancy(al):
    """
    CL2discrepancy(array_link al) -> double

    double CL2discrepancy(const
    array_link &al)

    calculate centered L2-discrepancy

    The method is from "A connection between uniformity and aberration in
    regular fractions of two-level factorials", Fang and Mukerjee, 2000

    """
    return _oalib.CL2discrepancy(al)

def array2secondorder(al):
    """
    array2secondorder(array_link al) -> array_link

    array_link
    array2secondorder(const array_link &al)

    calculate second order interaction matrix for 2-level array (does not
    include intercept and matrix itself) 
    """
    return _oalib.array2secondorder(al)

def array2xf(al):
    """
    array2xf(array_link al) -> array_link

    array_link array2xf(const array_link
    &al)

    add intercept and second order interactions to a 2-level array 
    """
    return _oalib.array2xf(al)

def array2xfeigen(al):
    """
    array2xfeigen(array_link al) -> Eigen::MatrixXd

    Eigen::MatrixXd
    array2xfeigen(const array_link &al)

    add intercept and second order interactions to an array 
    """
    return _oalib.array2xfeigen(al)

def arrayrankFullPivQR(al, threshold=-1):
    """
    arrayrankFullPivQR(array_link al, double threshold=-1) -> int
    arrayrankFullPivQR(array_link al) -> int

    int
    arrayrankFullPivQR(const array_link &al, double threshold=-1)

    return rank of an array based on FullPivHouseholderQR (defined at
    compile time) 
    """
    return _oalib.arrayrankFullPivQR(al, threshold)

def arrayrankColPivQR(al, threshold=-1):
    """
    arrayrankColPivQR(array_link al, double threshold=-1) -> int
    arrayrankColPivQR(array_link al) -> int

    int arrayrankColPivQR(const
    array_link &al, double threshold=-1)

    return rank of an array based on ColPivHouseholderQR (defined at
    compile time) 
    """
    return _oalib.arrayrankColPivQR(al, threshold)

def arrayrankFullPivLU(al, threshold=-1):
    """
    arrayrankFullPivLU(array_link al, double threshold=-1) -> int
    arrayrankFullPivLU(array_link al) -> int

    int
    arrayrankFullPivLU(const array_link &al, double threshold=-1) 
    """
    return _oalib.arrayrankFullPivLU(al, threshold)

def arrayrankSVD(al, threshold=-1):
    """
    arrayrankSVD(array_link al, double threshold=-1) -> int
    arrayrankSVD(array_link al) -> int

    int arrayrankSVD(const
    array_link &al, double threshold=-1) 
    """
    return _oalib.arrayrankSVD(al, threshold)

def arrayrank(al):
    """
    arrayrank(array_link al) -> int

    int arrayrank(const array_link &al)

    calculate the rank of an array 
    """
    return _oalib.arrayrank(al)

def arrayrankInfo(*args):
    """
    arrayrankInfo(Eigen::MatrixXd const & arg1, int verbose=1) -> int
    arrayrankInfo(Eigen::MatrixXd const & arg1) -> int
    arrayrankInfo(array_link al, int verbose=1) -> int
    arrayrankInfo(array_link al) -> int

    int arrayrankInfo(const
    array_link &al, int verbose=1)

    print information related to rank calculations 
    """
    return _oalib.arrayrankInfo(*args)

def arraylink2eigen(al):
    """
    arraylink2eigen(array_link al) -> Eigen::MatrixXd

    Eigen::MatrixXd
    arraylink2eigen(const array_link &al)

    convert array_link to Eigen matrix 
    """
    return _oalib.arraylink2eigen(al)
class rankStructure(object):
    """


    Structure to efficiently calculate the rank of the second order
    interaction matrix of many arrays sharing a common subarray

    The input arrays are assumed to be of the form A_i = [A_0 X_i]

    C++ includes: arrayproperties.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    alsub = _swig_property(_oalib.rankStructure_alsub_get, _oalib.rankStructure_alsub_set)
    r = _swig_property(_oalib.rankStructure_r_get, _oalib.rankStructure_r_set)
    verbose = _swig_property(_oalib.rankStructure_verbose_get, _oalib.rankStructure_verbose_set)
    ks = _swig_property(_oalib.rankStructure_ks_get, _oalib.rankStructure_ks_set)
    nsub = _swig_property(_oalib.rankStructure_nsub_get, _oalib.rankStructure_nsub_set)
    id = _swig_property(_oalib.rankStructure_id_get, _oalib.rankStructure_id_set)

    def __init__(self, *args):
        """
        __init__(rankStructure self, array_link al, int nsub=3, int verbose=0) -> rankStructure
        __init__(rankStructure self, array_link al, int nsub=3) -> rankStructure
        __init__(rankStructure self, array_link al) -> rankStructure
        __init__(rankStructure self, int nsub=3, int id=-1) -> rankStructure
        __init__(rankStructure self, int nsub=3) -> rankStructure
        __init__(rankStructure self) -> rankStructure

        rankStructure::rankStructure(int nsub=3, int id=-1)

        constructor 
        """
        this = _oalib.new_rankStructure(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def info(self):
        """
        info(rankStructure self)

        void
        rankStructure::info() const 
        """
        return _oalib.rankStructure_info(self)


    def updateStructure(self, al):
        """
        updateStructure(rankStructure self, array_link al)

        void
        rankStructure::updateStructure(const array_link &al)

        update the structure cache with a new array 
        """
        return _oalib.rankStructure_updateStructure(self, al)


    def matrixP(self):
        """
        matrixP(rankStructure self) -> rankStructure::EigenDecomp::PermutationType

        EigenDecomp::PermutationType rankStructure::matrixP() const

        helper function 
        """
        return _oalib.rankStructure_matrixP(self)


    def rankdirect(self, A):
        """
        rankdirect(rankStructure self, Eigen::MatrixXd const & A) -> int

        int
        rankStructure::rankdirect(const Eigen::MatrixXd &A) const

        calculate the rank of an array directly, uses special threshold 
        """
        return _oalib.rankStructure_rankdirect(self, A)


    def rankxfdirect(self, al):
        """
        rankxfdirect(rankStructure self, array_link al) -> int

        int
        rankStructure::rankxfdirect(const array_link &al) const

        calculate the rank of the second order interaction matrix of an array
        directly 
        """
        return _oalib.rankStructure_rankxfdirect(self, al)


    def rankxf(self, al):
        """
        rankxf(rankStructure self, array_link al) -> int

        int
        rankStructure::rankxf(const array_link &al)

        calculate the rank of the second order interaction matrix of an array
        using the cache system 
        """
        return _oalib.rankStructure_rankxf(self, al)

    __swig_destroy__ = _oalib.delete_rankStructure
    __del__ = lambda self: None
rankStructure_swigregister = _oalib.rankStructure_swigregister
rankStructure_swigregister(rankStructure)


def conditionNumber(M):
    """
    conditionNumber(array_link M) -> double

    double conditionNumber(const
    Eigen::Matrix< Type,-1,-1 > A)

    return the condition number of a matrix 
    """
    return _oalib.conditionNumber(M)

_oalib.PARETOFUNCTION_DEFAULT_swigconstant(_oalib)
PARETOFUNCTION_DEFAULT = _oalib.PARETOFUNCTION_DEFAULT

_oalib.PARETOFUNCTION_J5_swigconstant(_oalib)
PARETOFUNCTION_J5 = _oalib.PARETOFUNCTION_J5

def calculateParetoEvenOdd(*args):
    """
    calculateParetoEvenOdd(stringVector infiles, char const * outfile, int verbose=1, arrayfile::arrayfilemode_t afmode, int nrows=-1, int ncols=-1, paretomethod_t paretomethod=PARETOFUNCTION_DEFAULT)
    calculateParetoEvenOdd(stringVector infiles, char const * outfile, int verbose=1, arrayfile::arrayfilemode_t afmode, int nrows=-1, int ncols=-1)
    calculateParetoEvenOdd(stringVector infiles, char const * outfile, int verbose=1, arrayfile::arrayfilemode_t afmode, int nrows=-1)
    calculateParetoEvenOdd(stringVector infiles, char const * outfile, int verbose=1, arrayfile::arrayfilemode_t afmode)
    calculateParetoEvenOdd(stringVector infiles, char const * outfile, int verbose=1)
    calculateParetoEvenOdd(stringVector infiles, char const * outfile)

    void
    calculateParetoEvenOdd(const std::vector< std::string > infiles, const
    char *outfile, int verbose=1, arrayfilemode_t afmode=ABINARY, int
    nrows=-1, int ncols=-1, paretomethod_t
    paretomethod=PARETOFUNCTION_DEFAULT)

    Calculate the Pareto optimal arrays from a list of array files

    Pareto optimality is calculated according to (rank; A3,A4; F4) 
    """
    return _oalib.calculateParetoEvenOdd(*args)

def parsePareto(arraylist, verbose, paretomethod=PARETOFUNCTION_DEFAULT):
    """
    parsePareto(arraylist_t arraylist, int verbose, paretomethod_t paretomethod=PARETOFUNCTION_DEFAULT) -> ParetoMultiLongLong
    parsePareto(arraylist_t arraylist, int verbose) -> ParetoMultiLongLong

    Pareto< mvalue_t < long >, long >
    parsePareto(const arraylist_t &arraylist, int verbose, paretomethod_t
    paretomethod=PARETOFUNCTION_DEFAULT) 
    """
    return _oalib.parsePareto(arraylist, verbose, paretomethod)

def A3A4(al):
    """
    A3A4(array_link al) -> mvalue_t_long

    mvalue_t< long > A3A4(const array_link
    &al)

    calculate A3 and A4 value for array 
    """
    return _oalib.A3A4(al)

def F4(al, verbose=1):
    """
    F4(array_link al, int verbose=1) -> mvalue_t_long
    F4(array_link al) -> mvalue_t_long

    mvalue_t< long > F4(const array_link &al,
    int verbose=1)

    calculate F4 value for 2-level array 
    """
    return _oalib.F4(al, verbose)

def Cvalue2Dvalue(C, ka):
    """
    Cvalue2Dvalue(double C, int ka) -> double

    double Cvalue2Dvalue(double C,
    int ka)

    convert C value to D-efficiency value 
    """
    return _oalib.Cvalue2Dvalue(C, ka)

def Dvalue2Cvalue(A, ka):
    """
    Dvalue2Cvalue(double A, int ka) -> double

    double Dvalue2Cvalue(double A,
    int ka)

    convert D-efficiency value to C value 
    """
    return _oalib.Dvalue2Cvalue(A, ka)

def get_oaindex(s, strength, N):
    """
    get_oaindex(array_t const * s, colindex_t const strength, colindex_t const N) -> int

    int get_oaindex(const array_t *s,
    const colindex_t strength, const colindex_t N)

    Return index of an array. 
    """
    return _oalib.get_oaindex(s, strength, N)

def md5(*args):
    """
    md5(void * data, int numbytes) -> std::string
    md5(std::string const filename) -> std::string

    std::string md5(const std::string
    filename)

    calculate md5 sum of a file on disk 
    """
    return _oalib.md5(*args)

def scoreD(dd, alpha):
    """
    scoreD(doubleVector dd, doubleVector alpha) -> double

    double scoreD(const std::vector<
    double > dd, const std::vector< double > alpha)

    calculate score from from set of efficiencies 
    """
    return _oalib.scoreD(dd, alpha)

_oalib.DOPTIM_UPDATE_swigconstant(_oalib)
DOPTIM_UPDATE = _oalib.DOPTIM_UPDATE

_oalib.DOPTIM_SWAP_swigconstant(_oalib)
DOPTIM_SWAP = _oalib.DOPTIM_SWAP

_oalib.DOPTIM_FLIP_swigconstant(_oalib)
DOPTIM_FLIP = _oalib.DOPTIM_FLIP

_oalib.DOPTIM_AUTOMATIC_swigconstant(_oalib)
DOPTIM_AUTOMATIC = _oalib.DOPTIM_AUTOMATIC

_oalib.DOPTIM_NONE_swigconstant(_oalib)
DOPTIM_NONE = _oalib.DOPTIM_NONE

def optimDeff(A0, arrayclass, alpha, verbose=1, optimmethod=DOPTIM_AUTOMATIC, niter=100000, nabort=0):
    """
    optimDeff(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC, int niter=100000, int nabort=0) -> array_link
    optimDeff(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC, int niter=100000) -> array_link
    optimDeff(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC) -> array_link
    optimDeff(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1) -> array_link
    optimDeff(array_link A0, arraydata_t arrayclass, doubleVector alpha) -> array_link

    array_link optimDeff(const
    array_link &A0, const arraydata_t &arrayclass, std::vector< double >
    alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC, int
    niter=100000, int nabort=0)

    Optimize a design according to the optimization function specified.

    Arguments: arrayclass: structure describing the design class alpha:
    (3x1 array) verbose: output level 
    """
    return _oalib.optimDeff(A0, arrayclass, alpha, verbose, optimmethod, niter, nabort)

def optimDeff2level(A0, arrayclass, alpha, verbose=1, optimmethod=DOPTIM_AUTOMATIC, niter=100000, nabort=0):
    """
    optimDeff2level(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC, int niter=100000, int nabort=0) -> array_link
    optimDeff2level(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC, int niter=100000) -> array_link
    optimDeff2level(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int optimmethod=DOPTIM_AUTOMATIC) -> array_link
    optimDeff2level(array_link A0, arraydata_t arrayclass, doubleVector alpha, int verbose=1) -> array_link
    optimDeff2level(array_link A0, arraydata_t arrayclass, doubleVector alpha) -> array_link

    array_link
    optimDeff2level(const array_link &A0, const arraydata_t &arrayclass,
    std::vector< double > alpha, int verbose=1, int
    optimmethod=DOPTIM_AUTOMATIC, int niter=100000, int nabort=0)

    debugging function 
    """
    return _oalib.optimDeff2level(A0, arrayclass, alpha, verbose, optimmethod, niter, nabort)
class DoptimReturn(object):
    """


    Structure containing results of the Doptimize function.

    C++ includes: Deff.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dds = _swig_property(_oalib.DoptimReturn_dds_get, _oalib.DoptimReturn_dds_set)
    designs = _swig_property(_oalib.DoptimReturn_designs_get, _oalib.DoptimReturn_designs_set)
    nrestarts = _swig_property(_oalib.DoptimReturn_nrestarts_get, _oalib.DoptimReturn_nrestarts_set)
    nimproved = _swig_property(_oalib.DoptimReturn_nimproved_get, _oalib.DoptimReturn_nimproved_set)

    def __init__(self):
        """
        __init__(DoptimReturn self) -> DoptimReturn



        Structure containing results of the Doptimize function.

        C++ includes: Deff.h 
        """
        this = _oalib.new_DoptimReturn()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_DoptimReturn
    __del__ = lambda self: None
DoptimReturn_swigregister = _oalib.DoptimReturn_swigregister
DoptimReturn_swigregister(DoptimReturn)


def Doptimize(arrayclass, nrestarts, alpha, verbose, method=DOPTIM_AUTOMATIC, niter=300000, maxtime=100000, nabort=5000):
    """
    Doptimize(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000, double maxtime=100000, int nabort=5000) -> DoptimReturn
    Doptimize(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000, double maxtime=100000) -> DoptimReturn
    Doptimize(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000) -> DoptimReturn
    Doptimize(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC) -> DoptimReturn
    Doptimize(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose) -> DoptimReturn

    DoptimReturn Doptimize(const
    arraydata_t &arrayclass, int nrestarts, const std::vector< double >
    alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000,
    double maxtime=100000, int nabort=5000)

    function to generate optimal designs 
    """
    return _oalib.Doptimize(arrayclass, nrestarts, alpha, verbose, method, niter, maxtime, nabort)

def DoptimizeDebug(arrayclass, nrestarts, alpha, verbose, method=DOPTIM_AUTOMATIC, niter=300000, maxtime=100000, nabort=5000):
    """
    DoptimizeDebug(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000, double maxtime=100000, int nabort=5000) -> DoptimReturn
    DoptimizeDebug(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000, double maxtime=100000) -> DoptimReturn
    DoptimizeDebug(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC, int niter=300000) -> DoptimReturn
    DoptimizeDebug(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose, int method=DOPTIM_AUTOMATIC) -> DoptimReturn
    DoptimizeDebug(arraydata_t arrayclass, int nrestarts, doubleVector alpha, int verbose) -> DoptimReturn

    DoptimReturn
    DoptimizeDebug(const arraydata_t &arrayclass, int nrestarts, const
    std::vector< double > alpha, int verbose, int method=DOPTIM_AUTOMATIC,
    int niter=300000, double maxtime=100000, int nabort=5000)

    helper function 
    """
    return _oalib.DoptimizeDebug(arrayclass, nrestarts, alpha, verbose, method, niter, maxtime, nabort)

def DoptimizeMixed(sols, arrayclass, alpha, verbose=1, nabort=-1):
    """
    DoptimizeMixed(arraylist_t sols, arraydata_t arrayclass, doubleVector alpha, int verbose=1, int nabort=-1) -> DoptimReturn
    DoptimizeMixed(arraylist_t sols, arraydata_t arrayclass, doubleVector alpha, int verbose=1) -> DoptimReturn
    DoptimizeMixed(arraylist_t sols, arraydata_t arrayclass, doubleVector alpha) -> DoptimReturn

    DoptimReturn
    DoptimizeMixed(const arraylist_t &sols, const arraydata_t &arrayclass,
    const std::vector< double > alpha, int verbose=1, int nabort=-1) 
    """
    return _oalib.DoptimizeMixed(sols, arrayclass, alpha, verbose, nabort)
class OAextend(object):
    """


    Options for the extend code.

    class containing parameters of the extension and LMC algorithm

    C++ includes: extend.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    singleExtendTime = _swig_property(_oalib.OAextend_singleExtendTime_get, _oalib.OAextend_singleExtendTime_set)
    nLMC = _swig_property(_oalib.OAextend_nLMC_get, _oalib.OAextend_nLMC_set)
    checkarrays = _swig_property(_oalib.OAextend_checkarrays_get, _oalib.OAextend_checkarrays_set)
    check_maximal = _swig_property(_oalib.OAextend_check_maximal_get, _oalib.OAextend_check_maximal_set)
    use_row_symmetry = _swig_property(_oalib.OAextend_use_row_symmetry_get, _oalib.OAextend_use_row_symmetry_set)
    init_column_previous = _swig_property(_oalib.OAextend_init_column_previous_get, _oalib.OAextend_init_column_previous_set)
    APPENDEXTENSION = _oalib.OAextend_APPENDEXTENSION
    APPENDFULL = _oalib.OAextend_APPENDFULL
    STOREARRAY = _oalib.OAextend_STOREARRAY
    NONE = _oalib.OAextend_NONE
    extendarraymode = _swig_property(_oalib.OAextend_extendarraymode_get, _oalib.OAextend_extendarraymode_set)
    storefile = _swig_property(_oalib.OAextend_storefile_get, _oalib.OAextend_storefile_set)
    j5structure = _swig_property(_oalib.OAextend_j5structure_get, _oalib.OAextend_j5structure_set)

    def __init__(self, *args):
        """
        __init__(OAextend self) -> OAextend
        __init__(OAextend self, OAextend o) -> OAextend
        __init__(OAextend self, arraydata_t ad) -> OAextend

        OAextend::OAextend(arraydata_t &ad) 
        """
        this = _oalib.new_OAextend(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def setAlgorithm(self, algorithm, ad=None):
        """
        setAlgorithm(OAextend self, algorithm_t algorithm, arraydata_t ad=None)
        setAlgorithm(OAextend self, algorithm_t algorithm)

        void
        OAextend::setAlgorithm(algorithm_t algorithm, arraydata_t *ad=0)

        Set the algorithm to use for LMC checks. 
        """
        return _oalib.OAextend_setAlgorithm(self, algorithm, ad)


    def setAlgorithmAuto(self, ad=None):
        """
        setAlgorithmAuto(OAextend self, arraydata_t ad=None)
        setAlgorithmAuto(OAextend self)

        void
        OAextend::setAlgorithmAuto(arraydata_t *ad=0)

        Set the algorithm automatically. 
        """
        return _oalib.OAextend_setAlgorithmAuto(self, ad)


    def getAlgorithm(self):
        """
        getAlgorithm(OAextend self) -> algorithm_t

        algorithm_t
        OAextend::getAlgorithm() const

        Return algorithm used. 
        """
        return _oalib.OAextend_getAlgorithm(self)


    def getAlgorithmName(self):
        """
        getAlgorithmName(OAextend self) -> std::string

        std::string
        OAextend::getAlgorithmName() const

        Return algorithm used (as string) 
        """
        return _oalib.OAextend_getAlgorithmName(self)


    def updateArraydata(self, ad=None):
        """
        updateArraydata(OAextend self, arraydata_t ad=None)
        updateArraydata(OAextend self)

        void
        OAextend::updateArraydata(arraydata_t *ad=0) const 
        """
        return _oalib.OAextend_updateArraydata(self, ad)


    def getPreferredAlgorithm(ad, verbose=0):
        """
        getPreferredAlgorithm(arraydata_t ad, int verbose=0) -> algorithm_t
        getPreferredAlgorithm(arraydata_t ad) -> algorithm_t
        """
        return _oalib.OAextend_getPreferredAlgorithm(ad, verbose)

    getPreferredAlgorithm = staticmethod(getPreferredAlgorithm)

    def info(self, vb=1):
        """
        info(OAextend self, int vb=1)
        info(OAextend self)

        void OAextend::info(int vb=1)
        const

        print configuration to stdout 
        """
        return _oalib.OAextend_info(self, vb)


    def __repr__(self):
        """
        __repr__(OAextend self) -> std::string

        std::string
        OAextend::__repr__() const 
        """
        return _oalib.OAextend___repr__(self)

    __swig_destroy__ = _oalib.delete_OAextend
    __del__ = lambda self: None
OAextend_swigregister = _oalib.OAextend_swigregister
OAextend_swigregister(OAextend)

def OAextend_getPreferredAlgorithm(ad, verbose=0):
    """
    getPreferredAlgorithm(arraydata_t ad, int verbose=0) -> algorithm_t
    OAextend_getPreferredAlgorithm(arraydata_t ad) -> algorithm_t
    """
    return _oalib.OAextend_getPreferredAlgorithm(ad, verbose)


def extend_arraylist(*args):
    """
    extend_arraylist(arraylist_t alist, arraydata_t fullad, OAextend oaextend, colindex_t extensioncol, arraylist_t extensions) -> int
    extend_arraylist(arraylist_t alist, arraydata_t fullad, OAextend oaextend) -> arraylist_t
    extend_arraylist(arraylist_t alist, arraydata_t fullad) -> arraylist_t

    arraylist_t
    extend_arraylist(const arraylist_t &alist, const arraydata_t &fullad)

    extend a list of arrays with default options 
    """
    return _oalib.extend_arraylist(*args)

def extend_array(*args):
    """
    extend_array(array_link al, arraydata_t fullad, OAextend oaextend) -> arraylist_t
    extend_array(array_link al, arraydata_t arrayclass) -> arraylist_t
    extend_array(carray_t * array, arraydata_t arg2, colindex_t const extensioncol, arraylist_t solutions, OAextend oaextend) -> int

    int extend_array(carray_t
    *array, const arraydata_t *, const colindex_t extensioncol,
    arraylist_t &solutions, OAextend const &oaextend)

    extend an array with a single column 
    """
    return _oalib.extend_array(*args)

def runExtendRoot(adata, nmax, verbose=0):
    """
    runExtendRoot(arraydata_t adata, int nmax, int verbose=0) -> arraylist_t
    runExtendRoot(arraydata_t adata, int nmax) -> arraylist_t

    arraylist_t
    runExtendRoot(arraydata_t adata, int nmax, int verbose=0)

    simple wrapper function 
    """
    return _oalib.runExtendRoot(adata, nmax, verbose)

_oalib.DFILTER_NONE_swigconstant(_oalib)
DFILTER_NONE = _oalib.DFILTER_NONE

_oalib.DFILTER_BASIC_swigconstant(_oalib)
DFILTER_BASIC = _oalib.DFILTER_BASIC

_oalib.DFILTER_MULTI_swigconstant(_oalib)
DFILTER_MULTI = _oalib.DFILTER_MULTI

_oalib.DCALC_ALWAYS_swigconstant(_oalib)
DCALC_ALWAYS = _oalib.DCALC_ALWAYS

_oalib.DCALC_COND_swigconstant(_oalib)
DCALC_COND = _oalib.DCALC_COND
class dextend_t(object):
    """


    Helper structure for dynamic extension.

    C++ includes: extend.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    NO_VALUE = _oalib.dextend_t_NO_VALUE
    lmctype = _swig_property(_oalib.dextend_t_lmctype_get, _oalib.dextend_t_lmctype_set)
    lastcol = _swig_property(_oalib.dextend_t_lastcol_get, _oalib.dextend_t_lastcol_set)
    Deff = _swig_property(_oalib.dextend_t_Deff_get, _oalib.dextend_t_Deff_set)
    filter = _swig_property(_oalib.dextend_t_filter_get, _oalib.dextend_t_filter_set)
    filtermode = _swig_property(_oalib.dextend_t_filtermode_get, _oalib.dextend_t_filtermode_set)
    Dcheck = _swig_property(_oalib.dextend_t_Dcheck_get, _oalib.dextend_t_Dcheck_set)
    directcheck = _swig_property(_oalib.dextend_t_directcheck_get, _oalib.dextend_t_directcheck_set)

    def __init__(self):
        """
        __init__(dextend_t self) -> dextend_t

        dextend_t::dextend_t()

        """
        this = _oalib.new_dextend_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def resize(self, nn):
        """
        resize(dextend_t self, int nn)

        void dextend_t::resize(int
        nn) 
        """
        return _oalib.dextend_t_resize(self, nn)


    def DefficiencyFilter(self, Dfinal, k, kfinal, Lmax, verbose=1):
        """
        DefficiencyFilter(dextend_t self, double Dfinal, int k, int kfinal, double Lmax, int verbose=1)
        DefficiencyFilter(dextend_t self, double Dfinal, int k, int kfinal, double Lmax)

        void
        dextend_t::DefficiencyFilter(double Dfinal, int k, int kfinal, double
        Lmax, int verbose=1)

        perform filtering using D-efficiency 
        """
        return _oalib.dextend_t_DefficiencyFilter(self, Dfinal, k, kfinal, Lmax, verbose)


    def filterArrays(self, al, earrays, earraysout, edata, verbose=1):
        """
        filterArrays(dextend_t self, array_link al, arraylist_t earrays, arraylist_t earraysout, vector_vector_double edata, int verbose=1) -> intVector
        filterArrays(dextend_t self, array_link al, arraylist_t earrays, arraylist_t earraysout, vector_vector_double edata) -> intVector

        std::vector<int>
        dextend_t::filterArrays(const array_link &al, const arraylist_t
        &earrays, arraylist_t &earraysout, std::vector< std::vector< double >
        > &edata, int verbose=1)

        filter the arrays based on values in filter 
        """
        return _oalib.dextend_t_filterArrays(self, al, earrays, earraysout, edata, verbose)

    ntotal = _swig_property(_oalib.dextend_t_ntotal_get, _oalib.dextend_t_ntotal_set)
    nlmc = _swig_property(_oalib.dextend_t_nlmc_get, _oalib.dextend_t_nlmc_set)
    n = _swig_property(_oalib.dextend_t_n_get, _oalib.dextend_t_n_set)
    DmaxDiscard = _swig_property(_oalib.dextend_t_DmaxDiscard_get, _oalib.dextend_t_DmaxDiscard_set)
    nmaxrnktotal = _swig_property(_oalib.dextend_t_nmaxrnktotal_get, _oalib.dextend_t_nmaxrnktotal_set)
    __swig_destroy__ = _oalib.delete_dextend_t
    __del__ = lambda self: None
dextend_t_swigregister = _oalib.dextend_t_swigregister
dextend_t_swigregister(dextend_t)

class split(object):
    """Proxy of C++ split class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    st = _swig_property(_oalib.split_st_get, _oalib.split_st_set)
    count = _swig_property(_oalib.split_count_get, _oalib.split_count_set)
    stacksize = _swig_property(_oalib.split_stacksize_get, _oalib.split_stacksize_set)
    nvalid = _swig_property(_oalib.split_nvalid_get, _oalib.split_nvalid_set)
    cvalidpos = _swig_property(_oalib.split_cvalidpos_get, _oalib.split_cvalidpos_set)
    valid = _swig_property(_oalib.split_valid_get, _oalib.split_valid_set)

    def __init__(self, stacksize, maxs=26):
        """
        __init__(split self, rowindex_t stacksize, int maxs=26) -> split
        __init__(split self, rowindex_t stacksize) -> split
        """
        this = _oalib.new_split(stacksize, maxs)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_split
    __del__ = lambda self: None

    def position(self):
        """position(split self) -> rowindex_t"""
        return _oalib.split_position(self)


    def show(self):
        """show(split self)"""
        return _oalib.split_show(self)

split_swigregister = _oalib.split_swigregister
split_swigregister(split)


_oalib.LMC_LESS_swigconstant(_oalib)
LMC_LESS = _oalib.LMC_LESS

_oalib.LMC_EQUAL_swigconstant(_oalib)
LMC_EQUAL = _oalib.LMC_EQUAL

_oalib.LMC_MORE_swigconstant(_oalib)
LMC_MORE = _oalib.LMC_MORE

_oalib.LMC_NONSENSE_swigconstant(_oalib)
LMC_NONSENSE = _oalib.LMC_NONSENSE

_oalib.MODE_ORIGINAL_swigconstant(_oalib)
MODE_ORIGINAL = _oalib.MODE_ORIGINAL

_oalib.MODE_J4_swigconstant(_oalib)
MODE_J4 = _oalib.MODE_J4

_oalib.MODE_J5ORDER_swigconstant(_oalib)
MODE_J5ORDER = _oalib.MODE_J5ORDER

_oalib.MODE_J5ORDERX_swigconstant(_oalib)
MODE_J5ORDERX = _oalib.MODE_J5ORDERX

_oalib.MODE_INVALID_swigconstant(_oalib)
MODE_INVALID = _oalib.MODE_INVALID

_oalib.MODE_AUTOSELECT_swigconstant(_oalib)
MODE_AUTOSELECT = _oalib.MODE_AUTOSELECT

_oalib.MODE_LMC_SYMMETRY_swigconstant(_oalib)
MODE_LMC_SYMMETRY = _oalib.MODE_LMC_SYMMETRY

_oalib.MODE_LMC_2LEVEL_swigconstant(_oalib)
MODE_LMC_2LEVEL = _oalib.MODE_LMC_2LEVEL

_oalib.MODE_LMC_DEBUG_swigconstant(_oalib)
MODE_LMC_DEBUG = _oalib.MODE_LMC_DEBUG

_oalib.MODE_J5ORDERXFAST_swigconstant(_oalib)
MODE_J5ORDERXFAST = _oalib.MODE_J5ORDERXFAST

def algorithm_t_list():
    """
    algorithm_t_list() -> std::string

    std::string
    algorithm_t_list() 
    """
    return _oalib.algorithm_t_list()

_oalib.INITCOLUMN_ZERO_swigconstant(_oalib)
INITCOLUMN_ZERO = _oalib.INITCOLUMN_ZERO

_oalib.INITCOLUMN_PREVIOUS_swigconstant(_oalib)
INITCOLUMN_PREVIOUS = _oalib.INITCOLUMN_PREVIOUS

_oalib.INITCOLUMN_J5_swigconstant(_oalib)
INITCOLUMN_J5 = _oalib.INITCOLUMN_J5

_oalib.J5_ORIGINAL_swigconstant(_oalib)
J5_ORIGINAL = _oalib.J5_ORIGINAL

_oalib.J5_45_swigconstant(_oalib)
J5_45 = _oalib.J5_45

def algnames(m):
    """
    algnames(algorithm_t m) -> std::string

    std::string algnames(algorithm_t m)

    return name of the algorithm 
    """
    return _oalib.algnames(m)
class rowsort_t(object):
    """Proxy of C++ rowsort_t class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    r = _swig_property(_oalib.rowsort_t_r_get, _oalib.rowsort_t_r_set)
    val = _swig_property(_oalib.rowsort_t_val_get, _oalib.rowsort_t_val_set)

    def __init__(self):
        """__init__(rowsort_t self) -> rowsort_t"""
        this = _oalib.new_rowsort_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_rowsort_t
    __del__ = lambda self: None
rowsort_t_swigregister = _oalib.rowsort_t_swigregister
rowsort_t_swigregister(rowsort_t)


def __lt__(a, b):
    """__lt__(rowsort_t a, rowsort_t b) -> bool"""
    return _oalib.__lt__(a, b)

def __gt__(a, b):
    """__gt__(rowsort_t a, rowsort_t b) -> bool"""
    return _oalib.__gt__(a, b)

def apply_hadamard(*args):
    """
    apply_hadamard(arraydata_t ad, array_t * array, colindex_t hcol)
    apply_hadamard(array_link al, colindex_t hcol)

    void apply_hadamard(array_link
    &al, colindex_t hcol)

    Apply Hadamard transformation to orthogonal array. 
    """
    return _oalib.apply_hadamard(*args)
class LMC_static_struct_t(object):
    """


    Contains initialization data for static allocations.

    Part of the allocations is for structures that are constant and are
    re-used each time an LMC calculation is performed. Some other
    structures are temporary buffers that are written to all the time.

    C++ includes: lmc.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    LMC_non_root_init = _swig_property(_oalib.LMC_static_struct_t_LMC_non_root_init_get, _oalib.LMC_static_struct_t_LMC_non_root_init_set)
    LMC_root_init = _swig_property(_oalib.LMC_static_struct_t_LMC_root_init_get, _oalib.LMC_static_struct_t_LMC_root_init_set)
    LMC_reduce_root_rowperms_init = _swig_property(_oalib.LMC_static_struct_t_LMC_reduce_root_rowperms_init_get, _oalib.LMC_static_struct_t_LMC_reduce_root_rowperms_init_set)
    ad = _swig_property(_oalib.LMC_static_struct_t_ad_get, _oalib.LMC_static_struct_t_ad_set)
    LMC_root_rowperms_init = _swig_property(_oalib.LMC_static_struct_t_LMC_root_rowperms_init_get, _oalib.LMC_static_struct_t_LMC_root_rowperms_init_set)
    nrootrowperms = _swig_property(_oalib.LMC_static_struct_t_nrootrowperms_get, _oalib.LMC_static_struct_t_nrootrowperms_set)
    rootrowperms = _swig_property(_oalib.LMC_static_struct_t_rootrowperms_get, _oalib.LMC_static_struct_t_rootrowperms_set)
    LMC_root_rowperms_init_full = _swig_property(_oalib.LMC_static_struct_t_LMC_root_rowperms_init_full_get, _oalib.LMC_static_struct_t_LMC_root_rowperms_init_full_set)
    nrootrowperms_full = _swig_property(_oalib.LMC_static_struct_t_nrootrowperms_full_get, _oalib.LMC_static_struct_t_nrootrowperms_full_set)
    rootrowperms_full = _swig_property(_oalib.LMC_static_struct_t_rootrowperms_full_get, _oalib.LMC_static_struct_t_rootrowperms_full_set)
    colbuffer = _swig_property(_oalib.LMC_static_struct_t_colbuffer_get, _oalib.LMC_static_struct_t_colbuffer_set)
    dyndata_p = _swig_property(_oalib.LMC_static_struct_t_dyndata_p_get, _oalib.LMC_static_struct_t_dyndata_p_set)
    colperm_p = _swig_property(_oalib.LMC_static_struct_t_colperm_p_get, _oalib.LMC_static_struct_t_colperm_p_set)
    localcolperm_p = _swig_property(_oalib.LMC_static_struct_t_localcolperm_p_get, _oalib.LMC_static_struct_t_localcolperm_p_set)
    current_trans = _swig_property(_oalib.LMC_static_struct_t_current_trans_get, _oalib.LMC_static_struct_t_current_trans_set)

    def __init__(self):
        """
        __init__(LMC_static_struct_t self) -> LMC_static_struct_t

        LMC_static_struct_t::LMC_static_struct_t() 
        """
        this = _oalib.new_LMC_static_struct_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_LMC_static_struct_t
    __del__ = lambda self: None

    def show(self, verbose=1):
        """
        show(LMC_static_struct_t self, int verbose=1)
        show(LMC_static_struct_t self)

        void
        LMC_static_struct_t::show(int verbose=1) const 
        """
        return _oalib.LMC_static_struct_t_show(self, verbose)


    def init(self, adp):
        """
        init(LMC_static_struct_t self, arraydata_t adp)

        void
        LMC_static_struct_t::init(const arraydata_t *adp) 
        """
        return _oalib.LMC_static_struct_t_init(self, adp)


    def freeall(self):
        """
        freeall(LMC_static_struct_t self)

        void
        LMC_static_struct_t::freeall() 
        """
        return _oalib.LMC_static_struct_t_freeall(self)


    def update(self, adp):
        """
        update(LMC_static_struct_t self, arraydata_t adp) -> int

        int
        LMC_static_struct_t::update(const arraydata_t *adp)

        update structure with new design specification 
        """
        return _oalib.LMC_static_struct_t_update(self, adp)


    def needUpdate(self, adp):
        """
        needUpdate(LMC_static_struct_t self, arraydata_t adp) -> int

        int
        LMC_static_struct_t::needUpdate(const arraydata_t *adp) const 
        """
        return _oalib.LMC_static_struct_t_needUpdate(self, adp)


    def init_root_stage(self, lperm_p, colperm_p, adp):
        """
        init_root_stage(LMC_static_struct_t self, levelperm_t *& lperm_p, colperm_t *& colperm_p, arraydata_t adp)

        void
        LMC_static_struct_t::init_root_stage(levelperm_t *&lperm_p, colperm_t
        *&colperm_p, const arraydata_t *adp) 
        """
        return _oalib.LMC_static_struct_t_init_root_stage(self, lperm_p, colperm_p, adp)


    def init_nonroot_stage(self, lperm_p, colperm_p, localcolperm_p, dynd_p, dynd_p_nelem, colbuffer, adp):
        """
        init_nonroot_stage(LMC_static_struct_t self, levelperm_t *& lperm_p, colperm_t *& colperm_p, colperm_t *& localcolperm_p, dyndata_t **& dynd_p, int & dynd_p_nelem, array_t *& colbuffer, arraydata_t adp)

        void
        LMC_static_struct_t::init_nonroot_stage(levelperm_t *&lperm_p,
        colperm_t *&colperm_p, colperm_t *&localcolperm_p, dyndata_t
        **&dynd_p, int &dynd_p_nelem, array_t *&colbuffer, const arraydata_t
        *adp) const 
        """
        return _oalib.LMC_static_struct_t_init_nonroot_stage(self, lperm_p, colperm_p, localcolperm_p, dynd_p, dynd_p_nelem, colbuffer, adp)


    def init_rootrowperms(self, totalperms, rootrowperms, lperm_p):
        """
        init_rootrowperms(LMC_static_struct_t self, int & totalperms, rowperm_t *& rootrowperms, levelperm_t *& lperm_p)

        void
        LMC_static_struct_t::init_rootrowperms(int &totalperms, rowperm_t
        *&rootrowperms, levelperm_t *&lperm_p)

        Static initialization of root row permutations. 
        """
        return _oalib.LMC_static_struct_t_init_rootrowperms(self, totalperms, rootrowperms, lperm_p)


    def init_rootrowperms_full(self, totalperms, rootrowperms, lperm_p):
        """
        init_rootrowperms_full(LMC_static_struct_t self, int & totalperms, rowperm_t *& rootrowperms, levelperm_t *& lperm_p)

        void LMC_static_struct_t::init_rootrowperms_full(int &totalperms,
        rowperm_t *&rootrowperms, levelperm_t *&lperm_p)

        Static initialization of root row permutations (full group) 
        """
        return _oalib.LMC_static_struct_t_init_rootrowperms_full(self, totalperms, rootrowperms, lperm_p)

LMC_static_struct_t_swigregister = _oalib.LMC_static_struct_t_swigregister
LMC_static_struct_t_swigregister(LMC_static_struct_t)


def getGlobalStaticIndexed(n):
    """
    getGlobalStaticIndexed(int n) -> LMC_static_struct_t

    LMC_static_struct_t*
    getGlobalStaticIndexed(int n) 
    """
    return _oalib.getGlobalStaticIndexed(n)

def cleanGlobalStaticIndexed():
    """
    cleanGlobalStaticIndexed()

    void
    cleanGlobalStaticIndexed() 
    """
    return _oalib.cleanGlobalStaticIndexed()

def getGlobalStatic():
    """
    getGlobalStatic() -> LMC_static_struct_t

    LMC_static_struct_t*
    getGlobalStatic()

    return static structure from dynamic global pool, return with
    releaseGlobalStatic 
    """
    return _oalib.getGlobalStatic()

def releaseGlobalStatic(p):
    """
    releaseGlobalStatic(LMC_static_struct_t p)

    void
    releaseGlobalStatic(LMC_static_struct_t *p) 
    """
    return _oalib.releaseGlobalStatic(p)

def cleanGlobalStatic():
    """
    cleanGlobalStatic()

    void cleanGlobalStatic() 
    """
    return _oalib.cleanGlobalStatic()

def getGlobalStaticOne():
    """
    getGlobalStaticOne() -> LMC_static_struct_t

    LMC_static_struct_t&
    getGlobalStaticOne() 
    """
    return _oalib.getGlobalStaticOne()

_oalib.REDUCTION_INITIAL_swigconstant(_oalib)
REDUCTION_INITIAL = _oalib.REDUCTION_INITIAL

_oalib.REDUCTION_CHANGED_swigconstant(_oalib)
REDUCTION_CHANGED = _oalib.REDUCTION_CHANGED

_oalib.OA_TEST_swigconstant(_oalib)
OA_TEST = _oalib.OA_TEST

_oalib.OA_REDUCE_swigconstant(_oalib)
OA_REDUCE = _oalib.OA_REDUCE

_oalib.OA_REDUCE_PARTIAL_swigconstant(_oalib)
OA_REDUCE_PARTIAL = _oalib.OA_REDUCE_PARTIAL
class arraysymmetry(object):
    """


    class representing array symmetries

    C++ includes: lmc.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rowperm = _swig_property(_oalib.arraysymmetry_rowperm_get, _oalib.arraysymmetry_rowperm_set)
    colperm = _swig_property(_oalib.arraysymmetry_colperm_get, _oalib.arraysymmetry_colperm_set)
    rowpermpool = _swig_property(_oalib.arraysymmetry_rowpermpool_get, _oalib.arraysymmetry_rowpermpool_set)
    __swig_destroy__ = _oalib.delete_arraysymmetry
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(arraysymmetry self, dyndata_t dyndata) -> arraysymmetry
        __init__(arraysymmetry self, arraysymmetry rhs) -> arraysymmetry

        arraysymmetry::arraysymmetry(const arraysymmetry &rhs)

        copy constructor 
        """
        this = _oalib.new_arraysymmetry(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, as2):
        """__eq__(arraysymmetry self, arraysymmetry as2) -> int"""
        return _oalib.arraysymmetry___eq__(self, as2)


    def N(self):
        """
        N(arraysymmetry self) -> int

        int arraysymmetry::N() const

        """
        return _oalib.arraysymmetry_N(self)


    def show(self):
        """
        show(arraysymmetry self)

        void
        arraysymmetry::show() const 
        """
        return _oalib.arraysymmetry_show(self)

arraysymmetry_swigregister = _oalib.arraysymmetry_swigregister
arraysymmetry_swigregister(arraysymmetry)


def rootPlus(ad):
    """
    rootPlus(arraydata_t ad) -> array_link

    array_link rootPlus(const
    arraydata_t &ad)

    helper function 
    """
    return _oalib.rootPlus(ad)

_oalib.INIT_STATE_INVALID_swigconstant(_oalib)
INIT_STATE_INVALID = _oalib.INIT_STATE_INVALID

_oalib.COPY_swigconstant(_oalib)
COPY = _oalib.COPY

_oalib.INIT_swigconstant(_oalib)
INIT = _oalib.INIT

_oalib.SETROOT_swigconstant(_oalib)
SETROOT = _oalib.SETROOT
class LMCreduction_t(object):
    """


    Class to describe an LMC reduction.

    The most important variable is the transformation itself, contained in
    transformation. The state contains information about how the reduction
    was performed.

    C++ includes: lmc.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    array = _swig_property(_oalib.LMCreduction_t_array_get, _oalib.LMCreduction_t_array_set)
    transformation = _swig_property(_oalib.LMCreduction_t_transformation_get, _oalib.LMCreduction_t_transformation_set)
    mode = _swig_property(_oalib.LMCreduction_t_mode_get, _oalib.LMCreduction_t_mode_set)
    state = _swig_property(_oalib.LMCreduction_t_state_get, _oalib.LMCreduction_t_state_set)
    init_state = _swig_property(_oalib.LMCreduction_t_init_state_get, _oalib.LMCreduction_t_init_state_set)
    maxdepth = _swig_property(_oalib.LMCreduction_t_maxdepth_get, _oalib.LMCreduction_t_maxdepth_set)
    lastcol = _swig_property(_oalib.LMCreduction_t_lastcol_get, _oalib.LMCreduction_t_lastcol_set)
    nred = _swig_property(_oalib.LMCreduction_t_nred_get, _oalib.LMCreduction_t_nred_set)
    targetcol = _swig_property(_oalib.LMCreduction_t_targetcol_get, _oalib.LMCreduction_t_targetcol_set)
    mincol = _swig_property(_oalib.LMCreduction_t_mincol_get, _oalib.LMCreduction_t_mincol_set)
    nrows = _swig_property(_oalib.LMCreduction_t_nrows_get, _oalib.LMCreduction_t_nrows_set)
    ncols = _swig_property(_oalib.LMCreduction_t_ncols_get, _oalib.LMCreduction_t_ncols_set)
    staticdata = _swig_property(_oalib.LMCreduction_t_staticdata_get, _oalib.LMCreduction_t_staticdata_set)
    symms = _swig_property(_oalib.LMCreduction_t_symms_get, _oalib.LMCreduction_t_symms_set)
    sd = _swig_property(_oalib.LMCreduction_t_sd_get, _oalib.LMCreduction_t_sd_set)

    def __init__(self, *args):
        """
        __init__(LMCreduction_t self, LMCreduction_t at) -> LMCreduction_t
        __init__(LMCreduction_t self, arraydata_t ad) -> LMCreduction_t

        LMCreduction_t::LMCreduction_t(const arraydata_t *ad)

        copy constructor 
        """
        this = _oalib.new_LMCreduction_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_LMCreduction_t
    __del__ = lambda self: None

    def getArray(self):
        """
        getArray(LMCreduction_t self) -> array_link

        array_link
        LMCreduction_t::getArray() const

        Assignment operator. 
        """
        return _oalib.LMCreduction_t_getArray(self)


    def setArray(self, *args):
        """
        setArray(LMCreduction_t self, array_link al)
        setArray(LMCreduction_t self, array_t const * array, int nrows, int ncols)

        void
        LMCreduction_t::setArray(const array_t *array, int nrows, int ncols)

        """
        return _oalib.LMCreduction_t_setArray(self, *args)


    def updateSDpointer(self, al, cache=False):
        """
        updateSDpointer(LMCreduction_t self, array_link al, bool cache=False)
        updateSDpointer(LMCreduction_t self, array_link al)

        void
        LMCreduction_t::updateSDpointer(const array_link al, bool cache=false)

        """
        return _oalib.LMCreduction_t_updateSDpointer(self, al, cache)


    def clearSymmetries(self):
        """
        clearSymmetries(LMCreduction_t self)

        void
        LMCreduction_t::clearSymmetries() 
        """
        return _oalib.LMCreduction_t_clearSymmetries(self)


    def releaseStatic(self):
        """
        releaseStatic(LMCreduction_t self)

        void
        LMCreduction_t::releaseStatic() 
        """
        return _oalib.LMCreduction_t_releaseStatic(self)


    def initStatic(self):
        """
        initStatic(LMCreduction_t self)

        void
        LMCreduction_t::initStatic()

        acquire a reference to a LMC_static_struct_t object 
        """
        return _oalib.LMCreduction_t_initStatic(self)


    def getStaticReference(self):
        """
        getStaticReference(LMCreduction_t self) -> LMC_static_struct_t

        LMC_static_struct_t& LMCreduction_t::getStaticReference()

        return a reference to a LMC_static_struct_t object 
        """
        return _oalib.LMCreduction_t_getStaticReference(self)


    def reset(self):
        """
        reset(LMCreduction_t self)

        void
        LMCreduction_t::reset()

        reset the reduction: clears the symmetries and sets the transformation
        to zero 
        """
        return _oalib.LMCreduction_t_reset(self)


    def show(self, verbose=2):
        """
        show(LMCreduction_t self, int verbose=2)
        show(LMCreduction_t self)

        void
        LMCreduction_t::show(int verbose=2) const 
        """
        return _oalib.LMCreduction_t_show(self, verbose)


    def __repr__(self):
        """
        __repr__(LMCreduction_t self) -> std::string

        std::string
        LMCreduction_t::__repr__() const 
        """
        return _oalib.LMCreduction_t___repr__(self)


    def updateFromLoop(self, ad, dynd, lperms, original):
        """
        updateFromLoop(LMCreduction_t self, arraydata_t ad, dyndata_t dynd, levelperm_t * lperms, array_t const * original)

        void
        LMCreduction_t::updateFromLoop(const arraydata_t &ad, const dyndata_t
        &dynd, levelperm_t *lperms, const array_t *original)

        called whenever we find a reduction 
        """
        return _oalib.LMCreduction_t_updateFromLoop(self, ad, dynd, lperms, original)


    def updateTransformation(self, ad, dynd, lperms, original):
        """
        updateTransformation(LMCreduction_t self, arraydata_t ad, dyndata_t dynd, levelperm_t * lperms, array_t const * original)

        void
        LMCreduction_t::updateTransformation(const arraydata_t &ad, const
        dyndata_t &dynd, levelperm_t *lperms, const array_t *original) 
        """
        return _oalib.LMCreduction_t_updateTransformation(self, ad, dynd, lperms, original)


    def doBreak(self, ret):
        """
        doBreak(LMCreduction_t self, lmc_t ret) -> bool

        bool
        LMCreduction_t::doBreak(lmc_t ret) 
        """
        return _oalib.LMCreduction_t_doBreak(self, ret)


    def updateLastCol(self, col):
        """
        updateLastCol(LMCreduction_t self, int col)

        void
        LMCreduction_t::updateLastCol(int col) 
        """
        return _oalib.LMCreduction_t_updateLastCol(self, col)

LMCreduction_t_swigregister = _oalib.LMCreduction_t_swigregister
LMCreduction_t_swigregister(LMCreduction_t)

class dyndata_t(object):
    """


    Contains dynamic data of an array.

    The dynamic data are used in the inner loops of the LMC algorithm. In
    particular they keep track of the current row ordering and column
    permutation. By not applying these transformations to the array we can
    save calculation time.

    We try to prevent copying the object, so it is re-used at different
    levels in the algorithm. N: static col: changes at each column level

    rowsort: changes at each column level, used mainly in non-root stage

    colperm: changes at all levels See:   arraydata_t

    C++ includes: lmc.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    col = _swig_property(_oalib.dyndata_t_col_get, _oalib.dyndata_t_col_set)
    N = _swig_property(_oalib.dyndata_t_N_get, _oalib.dyndata_t_N_set)
    rowsort = _swig_property(_oalib.dyndata_t_rowsort_get, _oalib.dyndata_t_rowsort_set)
    rowsortl = _swig_property(_oalib.dyndata_t_rowsortl_get, _oalib.dyndata_t_rowsortl_set)
    colperm = _swig_property(_oalib.dyndata_t_colperm_get, _oalib.dyndata_t_colperm_set)

    def __init__(self, *args):
        """
        __init__(dyndata_t self, int N, int col=0) -> dyndata_t
        __init__(dyndata_t self, int N) -> dyndata_t
        __init__(dyndata_t self, dyndata_t dd) -> dyndata_t

        dyndata_t::dyndata_t(const dyndata_t &) 
        """
        this = _oalib.new_dyndata_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_dyndata_t
    __del__ = lambda self: None

    def show(self):
        """
        show(dyndata_t self)

        void dyndata_t::show() const

        """
        return _oalib.dyndata_t_show(self)


    def reset(self):
        """
        reset(dyndata_t self)

        void dyndata_t::reset() 
        """
        return _oalib.dyndata_t_reset(self)


    def setColperm(self, *args):
        """
        setColperm(dyndata_t self, colperm_t const perm, int n)
        setColperm(dyndata_t self, larray< colindex_t > const & perm)
        setColperm(dyndata_t self, intVector perm)

        void
        dyndata_t::setColperm(const std::vector< colindex_t > &perm) 
        """
        return _oalib.dyndata_t_setColperm(self, *args)


    def initsymmetry(self, arraysymm, sd, ncols):
        """
        initsymmetry(dyndata_t self, arraysymmetry arraysymm, symmdata sd, int ncols)

        void
        dyndata_t::initsymmetry(const arraysymmetry &arraysymm, const symmdata
        &sd, int ncols)

        initialize the rowsort structure from an arraysymmetry object 
        """
        return _oalib.dyndata_t_initsymmetry(self, arraysymm, sd, ncols)


    def getRowperm(self, *args):
        """
        getRowperm(dyndata_t self, rowpermtypelight & rp)
        getRowperm(dyndata_t self, rowperm_t & rperm)
        getRowperm(dyndata_t self) -> rowpermtypelight

        rowpermtypelight
        dyndata_t::getRowperm() const

        return lightweight row permutation 
        """
        return _oalib.dyndata_t_getRowperm(self, *args)


    def getColperm(self, *args):
        """
        getColperm(dyndata_t self) -> colpermtypelight
        getColperm(dyndata_t self, colpermtypelight & cp)

        void
        dyndata_t::getColperm(colpermtypelight &cp) const

        set column permutation 
        """
        return _oalib.dyndata_t_getColperm(self, *args)


    def allocrowsortl(self):
        """
        allocrowsortl(dyndata_t self)

        void
        dyndata_t::allocrowsortl()

        allocate lightweight rowsort structure 
        """
        return _oalib.dyndata_t_allocrowsortl(self)


    def deleterowsortl(self):
        """
        deleterowsortl(dyndata_t self)

        void
        dyndata_t::deleterowsortl() 
        """
        return _oalib.dyndata_t_deleterowsortl(self)


    def initrowsortl(self):
        """
        initrowsortl(dyndata_t self)

        void
        dyndata_t::initrowsortl() 
        """
        return _oalib.dyndata_t_initrowsortl(self)


    def rowsortl2rowsort(self):
        """
        rowsortl2rowsort(dyndata_t self)

        void
        dyndata_t::rowsortl2rowsort()

        helper function 
        """
        return _oalib.dyndata_t_rowsortl2rowsort(self)


    def copydata(self, dd):
        """
        copydata(dyndata_t self, dyndata_t dd)

        void
        dyndata_t::copydata(const dyndata_t &dd) 
        """
        return _oalib.dyndata_t_copydata(self, dd)

dyndata_t_swigregister = _oalib.dyndata_t_swigregister
dyndata_t_swigregister(dyndata_t)


def check_root_form(array, ad):
    """
    check_root_form(array_t const * array, arraydata_t ad) -> bool

    bool check_root_form(const
    array_t *array, const arraydata_t &ad)

    return true if target is in root form, otherwise return false 
    """
    return _oalib.check_root_form(array, ad)

def jj45val(array, N, jj, comb, j5val=-1, dosort=1):
    """
    jj45val(carray_t * array, rowindex_t N, int jj, colperm_t const comb, int j5val=-1, int dosort=1) -> jj45_t
    jj45val(carray_t * array, rowindex_t N, int jj, colperm_t const comb, int j5val=-1) -> jj45_t
    jj45val(carray_t * array, rowindex_t N, int jj, colperm_t const comb) -> jj45_t

    jj45_t jj45val(carray_t *array,
    rowindex_t N, int jj, const colperm_t comb, int j5val=-1, int
    dosort=1)

    return value based on J4-J5 ordering 
    """
    return _oalib.jj45val(array, N, jj, comb, j5val, dosort)

def random_transformation(array, adp):
    """
    random_transformation(array_t * array, arraydata_t adp)

    void
    random_transformation(array_t *array, const arraydata_t *adp)

    Apply a random transformation to an array 
    """
    return _oalib.random_transformation(array, adp)

def LMCreduction_train(*args):
    """
    LMCreduction_train(array_link al, arraydata_t ad, LMCreduction_t reduction, OAextend oaextend) -> lmc_t
    LMCreduction_train(array_t const * original, arraydata_t ad, dyndata_t dyndata, LMCreduction_t reduction, OAextend oaextend) -> lmc_t

    lmc_t
    LMCreduction_train(const array_t *original, const arraydata_t *ad,
    const dyndata_t *dyndata, LMCreduction_t *reduction, const OAextend
    &oaextend) 
    """
    return _oalib.LMCreduction_train(*args)

def LMCreduce(original, array, ad, dyndata, reduction, oaextend):
    """
    LMCreduce(array_t const * original, array_t const * array, arraydata_t ad, dyndata_t dyndata, LMCreduction_t reduction, OAextend oaextend) -> lmc_t

    lmc_t LMCreduce(array_t const
    *original, array_t const *array, const arraydata_t *ad, const
    dyndata_t *dyndata, LMCreduction_t *reduction, const OAextend
    &oaextend)

    helper function 
    """
    return _oalib.LMCreduce(original, array, ad, dyndata, reduction, oaextend)

def LMCcheck(*args):
    """
    LMCcheck(array_t const * array, arraydata_t ad, OAextend oaextend, LMCreduction_t reduction) -> lmc_t
    LMCcheck(array_link al, arraydata_t ad, OAextend oaextend, LMCreduction_t reduction) -> lmc_t

    lmc_t LMCcheck(const array_link &al,
    const arraydata_t &ad, const OAextend &oaextend, LMCreduction_t
    &reduction)

    generic LMCcheck function 
    """
    return _oalib.LMCcheck(*args)

def LMCcheckOriginal(al):
    """
    LMCcheckOriginal(array_link al) -> lmc_t

    lmc_t LMCcheckOriginal(const
    array_link &al)

    direct LMC check using the original LMC check 
    """
    return _oalib.LMCcheckOriginal(al)

def calculateSymmetryGroups(al, adata, oaextend, verbose=1, hack=0):
    """
    calculateSymmetryGroups(array_link al, arraydata_t adata, OAextend oaextend, int verbose=1, int hack=0) -> LMCreduction_t
    calculateSymmetryGroups(array_link al, arraydata_t adata, OAextend oaextend, int verbose=1) -> LMCreduction_t
    calculateSymmetryGroups(array_link al, arraydata_t adata, OAextend oaextend) -> LMCreduction_t

    LMCreduction_t
    calculateSymmetryGroups(const array_link &al, const arraydata_t
    &adata, const OAextend &oaextend, int verbose=1, int hack=0)

    helper function 
    """
    return _oalib.calculateSymmetryGroups(al, adata, oaextend, verbose, hack)

def LMCcheckSymmetryMethod(al, ad, oaextend, reduction, reductionsub, dverbose):
    """
    LMCcheckSymmetryMethod(array_link al, arraydata_t ad, OAextend oaextend, LMCreduction_t reduction, LMCreduction_t reductionsub, int dverbose) -> lmc_t

    lmc_t
    LMCcheckSymmetryMethod(const array_link &al, const arraydata_t &ad,
    const OAextend &oaextend, LMCreduction_t &reduction, LMCreduction_t
    &reductionsub, int dverbose) 
    """
    return _oalib.LMCcheckSymmetryMethod(al, ad, oaextend, reduction, reductionsub, dverbose)

def reduceArraysGWLP(input_arrays, reduced_arrays, verbose, dopruning=1, strength=2, dolmc=1):
    """
    reduceArraysGWLP(arraylist_t input_arrays, arraylist_t reduced_arrays, int verbose, int dopruning=1, int strength=2, int dolmc=1)
    reduceArraysGWLP(arraylist_t input_arrays, arraylist_t reduced_arrays, int verbose, int dopruning=1, int strength=2)
    reduceArraysGWLP(arraylist_t input_arrays, arraylist_t reduced_arrays, int verbose, int dopruning=1)
    reduceArraysGWLP(arraylist_t input_arrays, arraylist_t reduced_arrays, int verbose)

    void reduceArraysGWLP(const
    arraylist_t *input_arrays, arraylist_t &reduced_arrays, int verbose,
    int dopruning=1, int strength=2, int dolmc=1)

    reduce arrays to canonical form using delete-1-factor ordering 
    """
    return _oalib.reduceArraysGWLP(input_arrays, reduced_arrays, verbose, dopruning, strength, dolmc)

def reductionDOP(al, verbose=0):
    """
    reductionDOP(array_link al, int verbose=0) -> array_transformation_t
    reductionDOP(array_link al) -> array_transformation_t

    array_transformation_t
    reductionDOP(const array_link &al, int verbose=0) 
    """
    return _oalib.reductionDOP(al, verbose)

def selectUniqueArrays(xlist, earrays, verbose=1):
    """
    selectUniqueArrays(arraylist_t xlist, arraylist_t earrays, int verbose=1)
    selectUniqueArrays(arraylist_t xlist, arraylist_t earrays)

    void
    selectUniqueArrays(arraylist_t &xlist, arraylist_t &earrays, int
    verbose=1) 
    """
    return _oalib.selectUniqueArrays(xlist, earrays, verbose)

def reduceLMCform(al):
    """
    reduceLMCform(array_link al) -> array_link

    array_link reduceLMCform(const
    array_link &al)

    reduce an array to canonical form using LMC ordering 
    """
    return _oalib.reduceLMCform(al)

def reduceDOPform(al, verbose=0):
    """
    reduceDOPform(array_link al, int verbose=0) -> array_link
    reduceDOPform(array_link al) -> array_link

    array_link reduceDOPform(const
    array_link &al, int verbose=0)

    reduce an array to canonical form using delete-1-factor ordering 
    """
    return _oalib.reduceDOPform(al, verbose)

def LMCcheckLex(*args):
    """
    LMCcheckLex(arraylist_t list, arraydata_t ad, int verbose=0) -> intVector
    LMCcheckLex(arraylist_t list, arraydata_t ad) -> intVector
    LMCcheckLex(array_link al, arraydata_t ad) -> lmc_t

    lmc_t LMCcheckLex(array_link
    const &al, arraydata_t const &ad)

    Perform LMC check lexicographically. 
    """
    return _oalib.LMCcheckLex(*args)

def LMCcheckj4(al, ad, reduction, oaextend, jj=4):
    """
    LMCcheckj4(array_link al, arraydata_t ad, LMCreduction_t reduction, OAextend oaextend, int jj=4) -> lmc_t
    LMCcheckj4(array_link al, arraydata_t ad, LMCreduction_t reduction, OAextend oaextend) -> lmc_t

    lmc_t LMCcheckj4(array_link const
    &al, arraydata_t const &ad, LMCreduction_t &reduction, const OAextend
    &oaextend, int jj=4) 
    """
    return _oalib.LMCcheckj4(al, ad, reduction, oaextend, jj)

def LMCcheckj5(al, ad, reduction, oaextend, hack=0):
    """
    LMCcheckj5(array_link al, arraydata_t ad, LMCreduction_t reduction, OAextend oaextend, int hack=0) -> lmc_t
    LMCcheckj5(array_link al, arraydata_t ad, LMCreduction_t reduction, OAextend oaextend) -> lmc_t

    lmc_t LMCcheckj5(array_link const
    &al, arraydata_t const &ad, LMCreduction_t &reduction, const OAextend
    &oaextend, int hack=0)

    Perform LMC check with J5 ordering. 
    """
    return _oalib.LMCcheckj5(al, ad, reduction, oaextend, hack)

def root_row_permutation_from_index(permindex, ad, lperms):
    """
    root_row_permutation_from_index(int permindex, arraydata_t ad, levelperm_t * lperms)

    void
    root_row_permutation_from_index(int permindex, const arraydata_t *ad,
    levelperm_t *lperms) 
    """
    return _oalib.root_row_permutation_from_index(permindex, ad, lperms)

def create_root_permutations_index(ad, totalpermsr):
    """
    create_root_permutations_index(arraydata_t ad, int & totalpermsr) -> rowperm_t *

    rowperm_t*
    create_root_permutations_index(const arraydata_t *ad, int
    &totalpermsr) 
    """
    return _oalib.create_root_permutations_index(ad, totalpermsr)

def create_root_permutations_index_helper(rperms, lperms, ad, level, permcounter):
    """
    create_root_permutations_index_helper(rowperm_t * rperms, levelperm_t * lperms, arraydata_t ad, int level, int & permcounter)

    void
    create_root_permutations_index_helper(rowperm_t *rperms, levelperm_t
    *lperms, const arraydata_t *ad, int level, int &permcounter) 
    """
    return _oalib.create_root_permutations_index_helper(rperms, lperms, ad, level, permcounter)

def print_rowsort(rowsort, N):
    """
    print_rowsort(rowsort_t rowsort, int N)

    void print_rowsort(rowsort_t
    *rowsort, int N) 
    """
    return _oalib.print_rowsort(rowsort, N)

def print_column_rowsort(arraycol, rowsort, N):
    """
    print_column_rowsort(array_t const * arraycol, rowsort_t rowsort, int N)

    void
    print_column_rowsort(const array_t *arraycol, rowsort_t *rowsort, int
    N) 
    """
    return _oalib.print_column_rowsort(arraycol, rowsort, N)

def print_fracs(logl=NORMAL):
    """
    print_fracs(int logl=NORMAL)
    print_fracs()

    void print_fracs(int logl=NORMAL)

    """
    return _oalib.print_fracs(logl)

def clear_fracs():
    """
    clear_fracs()

    void clear_fracs() 
    """
    return _oalib.clear_fracs()

_oalib.ISOTOPY_swigconstant(_oalib)
ISOTOPY = _oalib.ISOTOPY

_oalib.MATRIX_ISOMORPHISM_swigconstant(_oalib)
MATRIX_ISOMORPHISM = _oalib.MATRIX_ISOMORPHISM

_oalib.CONFERENCE_ISOMORPHISM_swigconstant(_oalib)
CONFERENCE_ISOMORPHISM = _oalib.CONFERENCE_ISOMORPHISM

_oalib.OA_ISOMORPHISM_swigconstant(_oalib)
OA_ISOMORPHISM = _oalib.OA_ISOMORPHISM

def reduceNauty(G, colors, verbose=0):
    """
    reduceNauty(array_link G, intVector colors, int verbose=0) -> intVector
    reduceNauty(array_link G, intVector colors) -> intVector

    std::vector<int>
    nauty::reduceNauty(const array_link &G, std::vector< int > colors, int
    verbose=0)

    reduce a colored graph to Nauty minimal form

    The transformation returned is from the normal form to the specified
    graph. 
    """
    return _oalib.reduceNauty(G, colors, verbose)

def transformGraph(G, tr, verbose=1):
    """
    transformGraph(array_link G, intVector tr, int verbose=1) -> array_link
    transformGraph(array_link G, intVector tr) -> array_link
    """
    return _oalib.transformGraph(G, tr, verbose)

def reduceOAnauty(*args):
    """
    reduceOAnauty(array_link al, int verbose=0) -> array_transformation_t
    reduceOAnauty(array_link al) -> array_transformation_t
    reduceOAnauty(array_link al, int verbose, arraydata_t ad) -> array_transformation_t
    """
    return _oalib.reduceOAnauty(*args)

def array2graph(*args):
    """
    array2graph(array_link al, int verbose=1) -> pairGraphColors
    array2graph(array_link al) -> pairGraphColors
    array2graph(array_link al, int verbose, arraydata_t ad) -> pairGraphColors
    """
    return _oalib.array2graph(*args)

def oagraph2transformation(pp, arrayclass, verbose=1):
    """
    oagraph2transformation(intVector pp, arraydata_t arrayclass, int verbose=1) -> array_transformation_t
    oagraph2transformation(intVector pp, arraydata_t arrayclass) -> array_transformation_t
    """
    return _oalib.oagraph2transformation(pp, arrayclass, verbose)

def unittest_nautynormalform(al, verbose=1):
    """
    unittest_nautynormalform(array_link al, int verbose=1) -> int
    unittest_nautynormalform(array_link al) -> int
    """
    return _oalib.unittest_nautynormalform(al, verbose)
class depth_path_t(object):
    """


    structure containing current position in search tree

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ncurr = _swig_property(_oalib.depth_path_t_ncurr_get, _oalib.depth_path_t_ncurr_set)
    nmax = _swig_property(_oalib.depth_path_t_nmax_get, _oalib.depth_path_t_nmax_set)
    necols = _swig_property(_oalib.depth_path_t_necols_get, _oalib.depth_path_t_necols_set)
    ngecols = _swig_property(_oalib.depth_path_t_ngecols_get, _oalib.depth_path_t_ngecols_set)
    depthstart = _swig_property(_oalib.depth_path_t_depthstart_get, _oalib.depth_path_t_depthstart_set)

    def __init__(self):
        """
        __init__(depth_path_t self) -> depth_path_t

        depth_path_t::depth_path_t() 
        """
        this = _oalib.new_depth_path_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def updatePositionGEC(self, k, goodextensioncols):
        """
        updatePositionGEC(depth_path_t self, int k, int goodextensioncols)

        void
        depth_path_t::updatePositionGEC(int k, int goodextensioncols) 
        """
        return _oalib.depth_path_t_updatePositionGEC(self, k, goodextensioncols)


    def updatePosition(self, k, c, m, extensioncols, goodextensioncols):
        """
        updatePosition(depth_path_t self, int k, int c, int m, int extensioncols, int goodextensioncols)

        void
        depth_path_t::updatePosition(int k, int c, int m, int extensioncols,
        int goodextensioncols) 
        """
        return _oalib.depth_path_t_updatePosition(self, k, c, m, extensioncols, goodextensioncols)


    def show(self, depth, maxentries=8):
        """
        show(depth_path_t self, int depth, int maxentries=8)
        show(depth_path_t self, int depth)

        void
        depth_path_t::show(int depth, int maxentries=8) const 
        """
        return _oalib.depth_path_t_show(self, depth, maxentries)


    def init(self, ncols, _depthstart=9):
        """
        init(depth_path_t self, int ncols, int _depthstart=9)
        init(depth_path_t self, int ncols)

        void
        depth_path_t::init(int ncols, int _depthstart=9) 
        """
        return _oalib.depth_path_t_init(self, ncols, _depthstart)

    __swig_destroy__ = _oalib.delete_depth_path_t
    __del__ = lambda self: None
depth_path_t_swigregister = _oalib.depth_path_t_swigregister
depth_path_t_swigregister(depth_path_t)
CONFERENCE_RESTRICTED_ISOMORPHISM = cvar.CONFERENCE_RESTRICTED_ISOMORPHISM

class counter_t(object):
    """


    structure to count and show number of arrays generated, the structure
    is thread safe

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    nfound = _swig_property(_oalib.counter_t_nfound_get, _oalib.counter_t_nfound_set)

    def __init__(self, n):
        """
        __init__(counter_t self, int n) -> counter_t

        counter_t::counter_t(int
        n) 
        """
        this = _oalib.new_counter_t(n)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def addNfound(self, col, num):
        """
        addNfound(counter_t self, int col, int num)

        void
        counter_t::addNfound(int col, int num) 
        """
        return _oalib.counter_t_addNfound(self, col, num)


    def nArrays(self):
        """
        nArrays(counter_t self) -> long

        long counter_t::nArrays()
        const 
        """
        return _oalib.counter_t_nArrays(self)


    def clearNumberFound(self):
        """
        clearNumberFound(counter_t self)

        void
        counter_t::clearNumberFound() 
        """
        return _oalib.counter_t_clearNumberFound(self)


    def addNumberFound(self, *args):
        """
        addNumberFound(counter_t self, int n, int k)
        addNumberFound(counter_t self, counter_t de)

        void
        counter_t::addNumberFound(const counter_t &de) 
        """
        return _oalib.counter_t_addNumberFound(self, *args)


    def showcountscompact(self):
        """
        showcountscompact(counter_t self)

        void
        counter_t::showcountscompact() const

        show information about the number of arrays found 
        """
        return _oalib.counter_t_showcountscompact(self)


    def showcounts(self, *args):
        """
        showcounts(counter_t self, arraydata_t ad)
        showcounts(counter_t self, char const * str, int first, int last)

        void
        counter_t::showcounts(const char *str, int first, int last) const

        show information about the number of arrays found 
        """
        return _oalib.counter_t_showcounts(self, *args)

    __swig_destroy__ = _oalib.delete_counter_t
    __del__ = lambda self: None
counter_t_swigregister = _oalib.counter_t_swigregister
counter_t_swigregister(counter_t)

class depth_extend_sub_t(object):
    """


    Helper structure for dynamic extension

    In this structure we keep track of pointers to valid column extensions

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    lmctype = _swig_property(_oalib.depth_extend_sub_t_lmctype_get, _oalib.depth_extend_sub_t_lmctype_set)
    lastcol = _swig_property(_oalib.depth_extend_sub_t_lastcol_get, _oalib.depth_extend_sub_t_lastcol_set)
    strengthcheck = _swig_property(_oalib.depth_extend_sub_t_strengthcheck_get, _oalib.depth_extend_sub_t_strengthcheck_set)
    valididx = _swig_property(_oalib.depth_extend_sub_t_valididx_get, _oalib.depth_extend_sub_t_valididx_set)
    verbose = _swig_property(_oalib.depth_extend_sub_t_verbose_get, _oalib.depth_extend_sub_t_verbose_set)

    def __init__(self, nn=0):
        """
        __init__(depth_extend_sub_t self, int nn=0) -> depth_extend_sub_t
        __init__(depth_extend_sub_t self) -> depth_extend_sub_t

        depth_extend_sub_t::depth_extend_sub_t(int nn=0) 
        """
        this = _oalib.new_depth_extend_sub_t(nn)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def resize(self, nn):
        """
        resize(depth_extend_sub_t self, int nn)

        void
        depth_extend_sub_t::resize(int nn) 
        """
        return _oalib.depth_extend_sub_t_resize(self, nn)


    def n(self):
        """
        n(depth_extend_sub_t self) -> size_t

        size_t
        depth_extend_sub_t::n() const 
        """
        return _oalib.depth_extend_sub_t_n(self)


    def updateExtensionPointers(self, extcol):
        """
        updateExtensionPointers(depth_extend_sub_t self, int extcol) -> intVector

        std::vector< int > depth_extend_sub_t::updateExtensionPointers(int
        extcol) 
        """
        return _oalib.depth_extend_sub_t_updateExtensionPointers(self, extcol)


    def initialize(self, alist, adf, oaextend):
        """
        initialize(depth_extend_sub_t self, arraylist_t alist, arraydata_t adf, OAextend oaextend) -> arraylist_t

        arraylist_t
        depth_extend_sub_t::initialize(const arraylist_t &alist, const
        arraydata_t &adf, const OAextend &oaextend)

        initialize the new list of extension columns 
        """
        return _oalib.depth_extend_sub_t_initialize(self, alist, adf, oaextend)


    def selectArraysZ(self, alist):
        """
        selectArraysZ(depth_extend_sub_t self, arraylist_t alist) -> arraylist_t

        arraylist_t
        depth_extend_sub_t::selectArraysZ(const arraylist_t &alist) const

        select the arrays with are LMC and hence need to be written to disk 
        """
        return _oalib.depth_extend_sub_t_selectArraysZ(self, alist)


    def selectArraysXX(self, al, elist):
        """
        selectArraysXX(depth_extend_sub_t self, array_link al, arraylist_t elist) -> arraylist_t

        arraylist_t depth_extend_sub_t::selectArraysXX(const array_link &al,
        const arraylist_t &elist) const 
        """
        return _oalib.depth_extend_sub_t_selectArraysXX(self, al, elist)


    def info(self):
        """
        info(depth_extend_sub_t self)

        void
        depth_extend_sub_t::info() const 
        """
        return _oalib.depth_extend_sub_t_info(self)

    __swig_destroy__ = _oalib.delete_depth_extend_sub_t
    __del__ = lambda self: None
depth_extend_sub_t_swigregister = _oalib.depth_extend_sub_t_swigregister
depth_extend_sub_t_swigregister(depth_extend_sub_t)

class depth_extend_t(object):
    """


    Helper structure for dynamic extension.

    This structure allows for writing the generated arrays to disk. It
    also contains functions to print progress of the extension.

    Multiple copies of this class are made, but they all share the same
    counter_t and arraywriter_t object. Also t0 and tp are shared

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    verbose = _swig_property(_oalib.depth_extend_t_verbose_get, _oalib.depth_extend_t_verbose_set)
    oaextend = _swig_property(_oalib.depth_extend_t_oaextend_get, _oalib.depth_extend_t_oaextend_set)
    ad = _swig_property(_oalib.depth_extend_t_ad_get, _oalib.depth_extend_t_ad_set)
    loglevelcol = _swig_property(_oalib.depth_extend_t_loglevelcol_get, _oalib.depth_extend_t_loglevelcol_set)
    logtime = _swig_property(_oalib.depth_extend_t_logtime_get, _oalib.depth_extend_t_logtime_set)
    extension_column_list = _swig_property(_oalib.depth_extend_t_extension_column_list_get, _oalib.depth_extend_t_extension_column_list_set)
    writearrays = _swig_property(_oalib.depth_extend_t_writearrays_get, _oalib.depth_extend_t_writearrays_set)
    discardJ5 = _swig_property(_oalib.depth_extend_t_discardJ5_get, _oalib.depth_extend_t_discardJ5_set)
    discardJ5number = _swig_property(_oalib.depth_extend_t_discardJ5number_get, _oalib.depth_extend_t_discardJ5number_set)
    arraywriter = _swig_property(_oalib.depth_extend_t_arraywriter_get, _oalib.depth_extend_t_arraywriter_set)
    counter = _swig_property(_oalib.depth_extend_t_counter_get, _oalib.depth_extend_t_counter_set)
    t0 = _swig_property(_oalib.depth_extend_t_t0_get, _oalib.depth_extend_t_t0_set)
    tp = _swig_property(_oalib.depth_extend_t_tp_get, _oalib.depth_extend_t_tp_set)

    def __init__(self, *args):
        """
        __init__(depth_extend_t self, arraydata_t ad_, double _logtime=10000000, int _discardJ5=-1) -> depth_extend_t
        __init__(depth_extend_t self, arraydata_t ad_, double _logtime=10000000) -> depth_extend_t
        __init__(depth_extend_t self, arraydata_t ad_) -> depth_extend_t
        __init__(depth_extend_t self, depth_extend_t de) -> depth_extend_t

        depth_extend_t::depth_extend_t(const depth_extend_t &de) 
        """
        this = _oalib.new_depth_extend_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_depth_extend_t
    __del__ = lambda self: None

    def show(self):
        """
        show(depth_extend_t self)

        void
        depth_extend_t::show() 
        """
        return _oalib.depth_extend_t_show(self)


    def setNarraysMax(self, n):
        """
        setNarraysMax(depth_extend_t self, long n)

        void
        depth_extend_t::setNarraysMax(long n) 
        """
        return _oalib.depth_extend_t_setNarraysMax(self, n)


    def maxArrayCheck(self):
        """
        maxArrayCheck(depth_extend_t self)

        void
        depth_extend_t::maxArrayCheck()

        HACK 
        """
        return _oalib.depth_extend_t_maxArrayCheck(self)


    def showsearchpath(self, depth):
        """
        showsearchpath(depth_extend_t self, int depth)

        void
        depth_extend_t::showsearchpath(int depth) const 
        """
        return _oalib.depth_extend_t_showsearchpath(self, depth)


    def showprogress(self, showtime=1, depth=0, forcelog=0):
        """
        showprogress(depth_extend_t self, int showtime=1, int depth=0, int forcelog=0) -> bool
        showprogress(depth_extend_t self, int showtime=1, int depth=0) -> bool
        showprogress(depth_extend_t self, int showtime=1) -> bool
        showprogress(depth_extend_t self) -> bool

        bool
        depth_extend_t::showprogress(int showtime=1, int depth=0, int
        forcelog=0)

        show information about the progress of the loop 
        """
        return _oalib.depth_extend_t_showprogress(self, showtime, depth, forcelog)


    def info(self):
        """
        info(depth_extend_t self)

        void
        depth_extend_t::info() const 
        """
        return _oalib.depth_extend_t_info(self)


    def setposition(self, k, c, m, extensioncols=-1, goodextensioncols=-1):
        """
        setposition(depth_extend_t self, int k, int c, int m, int extensioncols=-1, int goodextensioncols=-1)
        setposition(depth_extend_t self, int k, int c, int m, int extensioncols=-1)
        setposition(depth_extend_t self, int k, int c, int m)

        void
        depth_extend_t::setposition(int k, int c, int m, int extensioncols=-1,
        int goodextensioncols=-1)

        set the position in the dextend structure 
        """
        return _oalib.depth_extend_t_setposition(self, k, c, m, extensioncols, goodextensioncols)


    def setpositionGEC(self, k, goodextensioncols):
        """
        setpositionGEC(depth_extend_t self, int k, int goodextensioncols)

        void
        depth_extend_t::setpositionGEC(int k, int goodextensioncols)

        set the position in the dextend structure 
        """
        return _oalib.depth_extend_t_setpositionGEC(self, k, goodextensioncols)

depth_extend_t_swigregister = _oalib.depth_extend_t_swigregister
depth_extend_t_swigregister(depth_extend_t)


_oalib.DEPTH_DIRECT_swigconstant(_oalib)
DEPTH_DIRECT = _oalib.DEPTH_DIRECT

_oalib.DEPTH_EXTENSIONS_swigconstant(_oalib)
DEPTH_EXTENSIONS = _oalib.DEPTH_EXTENSIONS
class depth_extensions_storage_t(object):
    """


    Helper structure for the even-odd depth extension.

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def resize(self, s):
        """
        resize(depth_extensions_storage_t self, size_t s)

        void
        depth_extensions_storage_t::resize(size_t s) 
        """
        return _oalib.depth_extensions_storage_t_resize(self, s)


    def set(self, ai, goodarrays, extension_column_list, depthalg, dextendsub):
        """
        set(depth_extensions_storage_t self, int ai, arraylist_t goodarrays, arraylist_t extension_column_list, depth_alg_t depthalg, depth_extend_sub_t dextendsub)

        void
        depth_extensions_storage_t::set(int ai, const arraylist_t &goodarrays,
        const arraylist_t &extension_column_list, depth_alg_t depthalg, const
        depth_extend_sub_t &dextendsub) 
        """
        return _oalib.depth_extensions_storage_t_set(self, ai, goodarrays, extension_column_list, depthalg, dextendsub)

    columnextensionsList = _swig_property(_oalib.depth_extensions_storage_t_columnextensionsList_get, _oalib.depth_extensions_storage_t_columnextensionsList_set)
    goodarrayslist = _swig_property(_oalib.depth_extensions_storage_t_goodarrayslist_get, _oalib.depth_extensions_storage_t_goodarrayslist_set)
    depthalglist = _swig_property(_oalib.depth_extensions_storage_t_depthalglist_get, _oalib.depth_extensions_storage_t_depthalglist_set)
    dextendsubList = _swig_property(_oalib.depth_extensions_storage_t_dextendsubList_get, _oalib.depth_extensions_storage_t_dextendsubList_set)

    def __init__(self):
        """
        __init__(depth_extensions_storage_t self) -> depth_extensions_storage_t



        Helper structure for the even-odd depth extension.

        C++ includes: evenodd.h 
        """
        this = _oalib.new_depth_extensions_storage_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_depth_extensions_storage_t
    __del__ = lambda self: None
depth_extensions_storage_t_swigregister = _oalib.depth_extensions_storage_t_swigregister
depth_extensions_storage_t_swigregister(depth_extensions_storage_t)


def processDepth(goodarrays, depthalg, dextend, dextendsublight, extensioncol, verbose=0):
    """
    processDepth(arraylist_t goodarrays, depth_alg_t depthalg, depth_extend_t dextend, depth_extend_sub_t dextendsublight, int extensioncol, int verbose=0)
    processDepth(arraylist_t goodarrays, depth_alg_t depthalg, depth_extend_t dextend, depth_extend_sub_t dextendsublight, int extensioncol)

    void processDepth(const
    arraylist_t &goodarrays, depth_alg_t depthalg, depth_extend_t
    &dextend, depth_extend_sub_t &dextendsublight, int extensioncol, int
    verbose=0)

    Extend arrays using a depth-first or breadth-first approach

    Parameters:
    -----------

    goodarrays:  List of arrays to extend

    depthalg:  Extend using depth-first or breadth-first

    dextend:  Option structure for the extension

    dextendsublight:  Data structure for the extensions

    extensioncol:  Column to extend

    verbose:  Verbosity level 
    """
    return _oalib.processDepth(goodarrays, depthalg, dextend, dextendsublight, extensioncol, verbose)

def depth_extend_hybrid(alist, dextend, extcol, oaextendx, verbose):
    """
    depth_extend_hybrid(arraylist_t alist, depth_extend_t dextend, int extcol, OAextend oaextendx, int verbose)

    void
    depth_extend_hybrid(const arraylist_t &alist, depth_extend_t &dextend,
    int extcol, const OAextend &oaextendx, int verbose)

    depth-first extension of arrays. depending on the symmetry group of
    the array to be extended a direct method is used or a method with
    caching of candidate columns 
    """
    return _oalib.depth_extend_hybrid(alist, dextend, extcol, oaextendx, verbose)

def depth_extend_direct(alist, dextend, extcol, oaextendx, verbose):
    """
    depth_extend_direct(arraylist_t alist, depth_extend_t dextend, int extcol, OAextend oaextendx, int verbose)

    void
    depth_extend_direct(const arraylist_t &alist, depth_extend_t &dextend,
    int extcol, const OAextend &oaextendx, int verbose)

    variation of depth_extend for arrays with large symmetry groups 
    """
    return _oalib.depth_extend_direct(alist, dextend, extcol, oaextendx, verbose)

def depth_extend_array(al, dextend, adfull, verbose, ds=None, arg6=0):
    """
    depth_extend_array(array_link al, depth_extend_t dextend, arraydata_t adfull, int verbose, depth_extensions_storage_t ds=None, int arg6=0)
    depth_extend_array(array_link al, depth_extend_t dextend, arraydata_t adfull, int verbose, depth_extensions_storage_t ds=None)
    depth_extend_array(array_link al, depth_extend_t dextend, arraydata_t adfull, int verbose)

    void
    depth_extend_array(const array_link &al, depth_extend_t &dextend,
    const arraydata_t &adfull, int verbose, depth_extensions_storage_t
    *ds=0, int=0)

    perform depth-first extension

    The arrays generated are pruned by keeping a list of possible
    extension valuesdepth extend a single array 
    """
    return _oalib.depth_extend_array(al, dextend, adfull, verbose, ds, arg6)

def addArraysToPareto(*args):
    """
    addArraysToPareto(Pareto< mvalue_t< long >,array_link > & pset, pareto_cb paretofunction, arraylist_t arraylist, int jj, int verbose)
    addArraysToPareto(Pareto< mvalue_t< long >,array_link > & pset, pareto_cb_cache paretofunction, arraylist_t arraylist, int jj, int verbose)

    void
    addArraysToPareto(Pareto< mvalue_t< long >, array_link > &pset,
    pareto_cb_cache paretofunction, const arraylist_t &arraylist, int jj,
    int verbose)

    add arrays to set of Pareto results 
    """
    return _oalib.addArraysToPareto(*args)
class jindex_t(object):
    """


    helper class for indexing statistics of designs

    The index consists of the number of columns and the value for the
    J-characteristic

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    k = _swig_property(_oalib.jindex_t_k_get, _oalib.jindex_t_k_set)
    j = _swig_property(_oalib.jindex_t_j_get, _oalib.jindex_t_j_set)

    def __init__(self, colindex, jvalue):
        """
        __init__(jindex_t self, int colindex, int jvalue) -> jindex_t

        jindex_t::jindex_t(int
        colindex, int jvalue) 
        """
        this = _oalib.new_jindex_t(colindex, jvalue)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __lt__(self, rhs):
        """__lt__(jindex_t self, jindex_t rhs) -> bool"""
        return _oalib.jindex_t___lt__(self, rhs)


    def toString(self):
        """
        toString(jindex_t self) -> std::string

        std::string
        jindex_t::toString() const 
        """
        return _oalib.jindex_t_toString(self)

    __swig_destroy__ = _oalib.delete_jindex_t
    __del__ = lambda self: None
jindex_t_swigregister = _oalib.jindex_t_swigregister
jindex_t_swigregister(jindex_t)

class Jcounter(object):
    """


    object to hold counts of maximum J_k-values

    C++ includes: evenodd.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    N = _swig_property(_oalib.Jcounter_N_get, _oalib.Jcounter_N_set)
    jj = _swig_property(_oalib.Jcounter_jj_get, _oalib.Jcounter_jj_set)
    fvals = _swig_property(_oalib.Jcounter_fvals_get, _oalib.Jcounter_fvals_set)
    maxJcounts = _swig_property(_oalib.Jcounter_maxJcounts_get, _oalib.Jcounter_maxJcounts_set)
    dt = _swig_property(_oalib.Jcounter_dt_get, _oalib.Jcounter_dt_set)

    def __init__(self, *args):
        """
        __init__(Jcounter self) -> Jcounter
        __init__(Jcounter self, int N, int jj=5, int k=-1) -> Jcounter
        __init__(Jcounter self, int N, int jj=5) -> Jcounter
        __init__(Jcounter self, int N) -> Jcounter

        Jcounter::Jcounter(int N,
        int jj=5, int k=-1) 
        """
        this = _oalib.new_Jcounter(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def validData(self):
        """
        validData(Jcounter self) -> bool

        bool
        Jcounter::validData() 
        """
        return _oalib.Jcounter_validData(self)


    def hasColumn(self, col):
        """
        hasColumn(Jcounter self, int col) -> bool

        bool
        Jcounter::hasColumn(int col) const

        return true if specified column is in the data 
        """
        return _oalib.Jcounter_hasColumn(self, col)


    def isOpen(self):
        """
        isOpen(Jcounter self) -> bool

        bool Jcounter::isOpen()
        const 
        """
        return _oalib.Jcounter_isOpen(self)


    def showPerformance(self):
        """
        showPerformance(Jcounter self)

        void
        Jcounter::showPerformance() const 
        """
        return _oalib.Jcounter_showPerformance(self)


    def narrays(self):
        """
        narrays(Jcounter self) -> long

        long Jcounter::narrays()
        const 
        """
        return _oalib.Jcounter_narrays(self)


    def show(self):
        """
        show(Jcounter self)

        void Jcounter::show() const

        show statistics of the object 
        """
        return _oalib.Jcounter_show(self)


    def maxCols(self):
        """
        maxCols(Jcounter self) -> int

        int Jcounter::maxCols()
        const 
        """
        return _oalib.Jcounter_maxCols(self)


    def getCount(self, k, j):
        """
        getCount(Jcounter self, int k, int j) -> long

        long
        Jcounter::getCount(int k, int j) const 
        """
        return _oalib.Jcounter_getCount(self, k, j)


    def getTotalsJvalue(self, jval):
        """
        getTotalsJvalue(Jcounter self, int jval) -> longVector

        std::vector<long>
        Jcounter::getTotalsJvalue(int jval) const 
        """
        return _oalib.Jcounter_getTotalsJvalue(self, jval)


    def getTotals(self):
        """
        getTotals(Jcounter self) -> longVector

        std::vector<long>
        Jcounter::getTotals() const 
        """
        return _oalib.Jcounter_getTotals(self)


    def showcompact(self):
        """
        showcompact(Jcounter self)

        void
        Jcounter::showcompact() const

        show statistics of the object 
        """
        return _oalib.Jcounter_showcompact(self)


    def __iadd__(self, jc):
        """__iadd__(Jcounter self, Jcounter jc) -> Jcounter"""
        return _oalib.Jcounter___iadd__(self, jc)


    def addArrays(self, arraylist, verbose=0):
        """
        addArrays(Jcounter self, arraylist_t arraylist, int verbose=0)
        addArrays(Jcounter self, arraylist_t arraylist)

        void
        Jcounter::addArrays(const arraylist_t &arraylist, int verbose=0)

        add list of arrays to object 
        """
        return _oalib.Jcounter_addArrays(self, arraylist, verbose)


    def addArray(self, al, verbose=0):
        """
        addArray(Jcounter self, array_link al, int verbose=0)
        addArray(Jcounter self, array_link al)

        void
        Jcounter::addArray(const array_link &al, int verbose=0)

        add single array to statistics object 
        """
        return _oalib.Jcounter_addArray(self, al, verbose)

    __swig_destroy__ = _oalib.delete_Jcounter
    __del__ = lambda self: None
Jcounter_swigregister = _oalib.Jcounter_swigregister
Jcounter_swigregister(Jcounter)


def readStatisticsFile(numbersfile, verbose):
    """
    readStatisticsFile(char const * numbersfile, int verbose) -> Jcounter

    Jcounter
    readStatisticsFile(const char *numbersfile, int verbose)

    read statistics object from disk 
    """
    return _oalib.readStatisticsFile(numbersfile, verbose)

def writeStatisticsFile(numbersfile, jc, verbose):
    """
    writeStatisticsFile(char const * numbersfile, Jcounter jc, int verbose)

    void
    writeStatisticsFile(const char *numbersfile, const Jcounter &jc, int
    verbose)

    write statistics object to disk 
    """
    return _oalib.writeStatisticsFile(numbersfile, jc, verbose)

def calculateJstatistics(afile, jj=5, verbose=1):
    """
    calculateJstatistics(char const * afile, int jj=5, int verbose=1) -> Jcounter
    calculateJstatistics(char const * afile, int jj=5) -> Jcounter
    calculateJstatistics(char const * afile) -> Jcounter

    Jcounter
    calculateJstatistics(const char *afile, int jj=5, int verbose=1)

    calculate J-value statistics 
    """
    return _oalib.calculateJstatistics(afile, jj, verbose)

def print_cperm(*args):
    """
    print_cperm(charVector c)
    print_cperm(char const * msg, charVector c)

    void print_cperm(const cperm &c)

    print a candidate extension 
    """
    return _oalib.print_cperm(*args)

def partial_inner_product(a, al, col, rmax):
    """
    partial_inner_product(charVector a, array_link al, int col, int rmax) -> int

    int
    partial_inner_product(const cperm &a, const array_link &al, int col,
    int rmax)

    partial inner product 
    """
    return _oalib.partial_inner_product(a, al, col, rmax)

def showCandidates(cc):
    """
    showCandidates(cpermVector cc)

    void showCandidates(const
    std::vector< cperm > &cc)

    show a list of candidate extensions 
    """
    return _oalib.showCandidates(cc)
class conf_candidates_t(object):
    """


    structure to cache a list of candidate extensions

    C++ includes: conference.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ce = _swig_property(_oalib.conf_candidates_t_ce_get, _oalib.conf_candidates_t_ce_set)

    def info(self, verbose=1):
        """
        info(conf_candidates_t self, int verbose=1)
        info(conf_candidates_t self)

        void
        conf_candidates_t::info(int verbose=1) const 
        """
        return _oalib.conf_candidates_t_info(self, verbose)


    def __init__(self):
        """
        __init__(conf_candidates_t self) -> conf_candidates_t



        structure to cache a list of candidate extensions

        C++ includes: conference.h 
        """
        this = _oalib.new_conf_candidates_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_conf_candidates_t
    __del__ = lambda self: None
conf_candidates_t_swigregister = _oalib.conf_candidates_t_swigregister
conf_candidates_t_swigregister(conf_candidates_t)

class conference_t(object):
    """


    Structure representing the type of conference designs.

    C++ includes: conference.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    N = _swig_property(_oalib.conference_t_N_get, _oalib.conference_t_N_set)
    ncols = _swig_property(_oalib.conference_t_ncols_get, _oalib.conference_t_ncols_set)
    CONFERENCE_NORMAL = _oalib.conference_t_CONFERENCE_NORMAL
    CONFERENCE_DIAGONAL = _oalib.conference_t_CONFERENCE_DIAGONAL
    DCONFERENCE = _oalib.conference_t_DCONFERENCE
    ctype = _swig_property(_oalib.conference_t_ctype_get, _oalib.conference_t_ctype_set)
    itype = _swig_property(_oalib.conference_t_itype_get, _oalib.conference_t_itype_set)
    j1zero = _swig_property(_oalib.conference_t_j1zero_get, _oalib.conference_t_j1zero_set)
    j3zero = _swig_property(_oalib.conference_t_j3zero_get, _oalib.conference_t_j3zero_set)

    def __init__(self, *args):
        """
        __init__(conference_t self) -> conference_t
        __init__(conference_t self, int N, int k, int j1zero) -> conference_t
        __init__(conference_t self, conference_t rhs) -> conference_t

        conference_t::conference_t(const conference_t &rhs) 
        """
        this = _oalib.new_conference_t(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def create_root(self):
        """
        create_root(conference_t self) -> array_link

        array_link
        conference_t::create_root() const

        create the unique representative of the 2 column design (for
        conference matrices) 
        """
        return _oalib.conference_t_create_root(self)


    def create_root_three(self):
        """
        create_root_three(conference_t self) -> array_link

        array_link
        conference_t::create_root_three() const

        create the unique representative of the 3 column design 
        """
        return _oalib.conference_t_create_root_three(self)


    def createDconferenceRootArrays(self):
        """
        createDconferenceRootArrays(conference_t self) -> arraylist_t

        arraylist_t conference_t::createDconferenceRootArrays() const 
        """
        return _oalib.conference_t_createDconferenceRootArrays(self)


    def addRootArrays(self, lst):
        """
        addRootArrays(conference_t self, arraylist_t lst)

        void
        conference_t::addRootArrays(arraylist_t &lst) const 
        """
        return _oalib.conference_t_addRootArrays(self, lst)


    def __repr__(self):
        """
        __repr__(conference_t self) -> std::string

        std::string
        conference_t::__repr__() const

        return string representation of the object 
        """
        return _oalib.conference_t___repr__(self)

    __swig_destroy__ = _oalib.delete_conference_t
    __del__ = lambda self: None
conference_t_swigregister = _oalib.conference_t_swigregister
conference_t_swigregister(conference_t)


def reduceConference(arg1, verbose=0):
    """
    reduceConference(array_link arg1, int verbose=0) -> array_link
    reduceConference(array_link arg1) -> array_link

    array_link
    reduceConference(const array_link &, int verbose=0)

    reduce conference matrix to normal form 
    """
    return _oalib.reduceConference(arg1, verbose)

def reduceConferenceTransformation(al, verbose):
    """
    reduceConferenceTransformation(array_link al, int verbose) -> conference_transformation_t

    conference_transformation_t reduceConferenceTransformation(const
    array_link &al, int verbose)

    reduce conference matrix to normal form 
    """
    return _oalib.reduceConferenceTransformation(al, verbose)
class conference_extend_t(object):
    """


    Helper structure.

    C++ includes: conference.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    first = _swig_property(_oalib.conference_extend_t_first_get, _oalib.conference_extend_t_first_set)
    second = _swig_property(_oalib.conference_extend_t_second_get, _oalib.conference_extend_t_second_set)
    extensions = _swig_property(_oalib.conference_extend_t_extensions_get, _oalib.conference_extend_t_extensions_set)

    def combine(self, i, j):
        """
        combine(conference_extend_t self, int i, int j) -> charVector

        cperm
        conference_extend_t::combine(int i, int j) const 
        """
        return _oalib.conference_extend_t_combine(self, i, j)


    def nExtensions(self):
        """
        nExtensions(conference_extend_t self) -> size_t

        size_t
        conference_extend_t::nExtensions() const 
        """
        return _oalib.conference_extend_t_nExtensions(self)


    def getarrays(self, al):
        """
        getarrays(conference_extend_t self, array_link al) -> arraylist_t

        arraylist_t
        conference_extend_t::getarrays(const array_link al) const 
        """
        return _oalib.conference_extend_t_getarrays(self, al)


    def __init__(self):
        """
        __init__(conference_extend_t self) -> conference_extend_t



        Helper structure.

        C++ includes: conference.h 
        """
        this = _oalib.new_conference_extend_t()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_conference_extend_t
    __del__ = lambda self: None
conference_extend_t_swigregister = _oalib.conference_extend_t_swigregister
conference_extend_t_swigregister(conference_extend_t)


def checkZeroPosition(p, zero_position):
    """checkZeroPosition(charVector p, int zero_position) -> bool"""
    return _oalib.checkZeroPosition(p, zero_position)

def filterZeroPosition(lst, zero_position):
    """filterZeroPosition(cpermVector lst, int zero_position) -> cpermVector"""
    return _oalib.filterZeroPosition(lst, zero_position)
class CandidateGeneratorBase(object):
    """Proxy of C++ CandidateGeneratorBase class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ct = _swig_property(_oalib.CandidateGeneratorBase_ct_get, _oalib.CandidateGeneratorBase_ct_set)
    verbose = _swig_property(_oalib.CandidateGeneratorBase_verbose_get, _oalib.CandidateGeneratorBase_verbose_set)
    al = _swig_property(_oalib.CandidateGeneratorBase_al_get, _oalib.CandidateGeneratorBase_al_set)
    last_valid = _swig_property(_oalib.CandidateGeneratorBase_last_valid_get, _oalib.CandidateGeneratorBase_last_valid_set)

    def __init__(self, al, ct):
        """__init__(CandidateGeneratorBase self, array_link al, conference_t ct) -> CandidateGeneratorBase"""
        this = _oalib.new_CandidateGeneratorBase(al, ct)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def showCandidates(self, verbose=1):
        """
        showCandidates(CandidateGeneratorBase self, int verbose=1)
        showCandidates(CandidateGeneratorBase self)

        void showCandidates(const
        std::vector< cperm > &cc)

        show a list of candidate extensions 
        """
        return _oalib.CandidateGeneratorBase_showCandidates(self, verbose)

    __swig_destroy__ = _oalib.delete_CandidateGeneratorBase
    __del__ = lambda self: None
CandidateGeneratorBase_swigregister = _oalib.CandidateGeneratorBase_swigregister
CandidateGeneratorBase_swigregister(CandidateGeneratorBase)

class CandidateGeneratorConference(CandidateGeneratorBase):
    """Proxy of C++ CandidateGeneratorConference class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, al, ct):
        """__init__(CandidateGeneratorConference self, array_link al, conference_t ct) -> CandidateGeneratorConference"""
        this = _oalib.new_CandidateGeneratorConference(al, ct)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def generateCandidates(self, al):
        """generateCandidates(CandidateGeneratorConference self, array_link al) -> cpermVector"""
        return _oalib.CandidateGeneratorConference_generateCandidates(self, al)


    def generateCandidatesZero(self, al, kz):
        """generateCandidatesZero(CandidateGeneratorConference self, array_link al, int kz) -> cpermVector"""
        return _oalib.CandidateGeneratorConference_generateCandidatesZero(self, al, kz)

    __swig_destroy__ = _oalib.delete_CandidateGeneratorConference
    __del__ = lambda self: None
CandidateGeneratorConference_swigregister = _oalib.CandidateGeneratorConference_swigregister
CandidateGeneratorConference_swigregister(CandidateGeneratorConference)

class CandidateGeneratorDouble(CandidateGeneratorBase):
    """


    Class to generate candidate extensions with caching.

    C++ includes: conference.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, al, ct):
        """
        __init__(CandidateGeneratorDouble self, array_link al, conference_t ct) -> CandidateGeneratorDouble

        CandidateGeneratorDouble::CandidateGeneratorDouble(const array_link
        &al, const conference_t &ct) 
        """
        this = _oalib.new_CandidateGeneratorDouble(al, ct)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def generateCandidates(self, al):
        """generateCandidates(CandidateGeneratorDouble self, array_link al) -> cpermVector"""
        return _oalib.CandidateGeneratorDouble_generateCandidates(self, al)

    __swig_destroy__ = _oalib.delete_CandidateGeneratorDouble
    __del__ = lambda self: None
CandidateGeneratorDouble_swigregister = _oalib.CandidateGeneratorDouble_swigregister
CandidateGeneratorDouble_swigregister(CandidateGeneratorDouble)


def extend_conference_matrix(al, ct, extcol, verbose=1, maxzpos=-1):
    """
    extend_conference_matrix(array_link al, conference_t ct, int extcol, int verbose=1, int maxzpos=-1) -> conference_extend_t
    extend_conference_matrix(array_link al, conference_t ct, int extcol, int verbose=1) -> conference_extend_t
    extend_conference_matrix(array_link al, conference_t ct, int extcol) -> conference_extend_t

    conference_extend_t
    extend_conference_matrix(const array_link &al, const conference_t &ct,
    int extcol, int verbose=1, int maxzpos=-1)

    Extend a single conference design with candidate columns 
    """
    return _oalib.extend_conference_matrix(al, ct, extcol, verbose, maxzpos)

def extend_conference(lst, ctype, verbose, select_isomorphism_classes=0):
    """
    extend_conference(arraylist_t lst, conference_t ctype, int verbose, int select_isomorphism_classes=0) -> arraylist_t
    extend_conference(arraylist_t lst, conference_t ctype, int verbose) -> arraylist_t

    arraylist_t
    extend_conference(const arraylist_t &lst, const conference_t ctype,
    int verbose, int select_isomorphism_classes=0)

    Extend a list of conference designs with a single column. 
    """
    return _oalib.extend_conference(lst, ctype, verbose, select_isomorphism_classes)

def extend_conference_plain(lst, ctype, verbose, select_isomorphism_classes=0):
    """
    extend_conference_plain(arraylist_t lst, conference_t ctype, int verbose, int select_isomorphism_classes=0) -> arraylist_t
    extend_conference_plain(arraylist_t lst, conference_t ctype, int verbose) -> arraylist_t

    arraylist_t
    extend_conference_plain(const arraylist_t &lst, const conference_t
    ctype, int verbose, int select_isomorphism_classes=0)

    plain version without caching 
    """
    return _oalib.extend_conference_plain(lst, ctype, verbose, select_isomorphism_classes)

def extend_conference_restricted(lst, ctype, verbose):
    """
    extend_conference_restricted(arraylist_t lst, conference_t ctype, int verbose) -> arraylist_t

    arraylist_t
    extend_conference_restricted(const arraylist_t &lst, const
    conference_t ctype, int verbose)

    Extend a list of conference designs with a single column 
    """
    return _oalib.extend_conference_restricted(lst, ctype, verbose)

def extend_double_conference(lst, ctype, verbose):
    """
    extend_double_conference(arraylist_t lst, conference_t ctype, int verbose) -> arraylist_t

    arraylist_t
    extend_double_conference(const arraylist_t &lst, const conference_t
    ctype, int verbose) 
    """
    return _oalib.extend_double_conference(lst, ctype, verbose)

def selectConferenceIsomorpismClasses(list, verbose, itype=CONFERENCE_ISOMORPHISM):
    """
    selectConferenceIsomorpismClasses(arraylist_t list, int verbose, matrix_isomorphism_t itype=CONFERENCE_ISOMORPHISM) -> arraylist_t
    selectConferenceIsomorpismClasses(arraylist_t list, int verbose) -> arraylist_t

    arraylist_t
    selectConferenceIsomorpismClasses(const arraylist_t &list, int
    verbose, matrix_isomorphism_t itype=CONFERENCE_ISOMORPHISM)

    select representatives for the isomorphism classes of a list of
    conference arrays 
    """
    return _oalib.selectConferenceIsomorpismClasses(list, verbose, itype)

def selectConferenceIsomorpismIndices(lst, verbose, itype=CONFERENCE_ISOMORPHISM):
    """
    selectConferenceIsomorpismIndices(arraylist_t lst, int verbose, matrix_isomorphism_t itype=CONFERENCE_ISOMORPHISM) -> intVector
    selectConferenceIsomorpismIndices(arraylist_t lst, int verbose) -> intVector

    std::vector<int> selectConferenceIsomorpismIndices(const arraylist_t
    &lst, int verbose, matrix_isomorphism_t itype=CONFERENCE_ISOMORPHISM)

    select representatives for the isomorphism classes of a list of
    conference arrays, return indices of classes 
    """
    return _oalib.selectConferenceIsomorpismIndices(lst, verbose, itype)

def selectLMC0doubleconference(list, verbose, ctype):
    """selectLMC0doubleconference(arraylist_t list, int verbose, conference_t ctype) -> arraylist_t"""
    return _oalib.selectLMC0doubleconference(list, verbose, ctype)

def selectLMC0(list, verbose, ctype):
    """
    selectLMC0(arraylist_t list, int verbose, conference_t ctype) -> arraylist_t

    arraylist_t selectLMC0(const
    arraylist_t &list, int verbose, const conference_t &ctype) 
    """
    return _oalib.selectLMC0(list, verbose, ctype)

def generateConferenceExtensions(al, ct, kz, verbose=1, filtersymm=1, filterj2=1):
    """
    generateConferenceExtensions(array_link al, conference_t ct, int kz, int verbose=1, int filtersymm=1, int filterj2=1) -> cpermVector
    generateConferenceExtensions(array_link al, conference_t ct, int kz, int verbose=1, int filtersymm=1) -> cpermVector
    generateConferenceExtensions(array_link al, conference_t ct, int kz, int verbose=1) -> cpermVector
    generateConferenceExtensions(array_link al, conference_t ct, int kz) -> cpermVector

    std::vector<cperm> generateConferenceExtensions(const array_link &al,
    const conference_t &ct, int kz, int verbose=1, int filtersymm=1, int
    filterip=1)

    Generate candidate extensions

    Parameters:
    -----------

    al:  design to be extended

    kz:  index of zero in candidate column 
    """
    return _oalib.generateConferenceExtensions(al, ct, kz, verbose, filtersymm, filterj2)

def generateConferenceRestrictedExtensions(al, ct, kz, verbose=1, filtersymm=1, filterip=1):
    """
    generateConferenceRestrictedExtensions(array_link al, conference_t ct, int kz, int verbose=1, int filtersymm=1, int filterip=1) -> cpermVector
    generateConferenceRestrictedExtensions(array_link al, conference_t ct, int kz, int verbose=1, int filtersymm=1) -> cpermVector
    generateConferenceRestrictedExtensions(array_link al, conference_t ct, int kz, int verbose=1) -> cpermVector
    generateConferenceRestrictedExtensions(array_link al, conference_t ct, int kz) -> cpermVector

    std::vector<cperm> generateConferenceRestrictedExtensions(const
    array_link &al, const conference_t &ct, int kz, int verbose=1, int
    filtersymm=1, int filterip=1)

    Generate candidate extensions for restricted isomorphism classes 
    """
    return _oalib.generateConferenceRestrictedExtensions(al, ct, kz, verbose, filtersymm, filterip)

def generateDoubleConferenceExtensions(al, ct, verbose=1, filtersymm=1, filterip=1, filterJ3=0, filtersymminline=1):
    """
    generateDoubleConferenceExtensions(array_link al, conference_t ct, int verbose=1, int filtersymm=1, int filterip=1, int filterJ3=0, int filtersymminline=1) -> cpermVector
    generateDoubleConferenceExtensions(array_link al, conference_t ct, int verbose=1, int filtersymm=1, int filterip=1, int filterJ3=0) -> cpermVector
    generateDoubleConferenceExtensions(array_link al, conference_t ct, int verbose=1, int filtersymm=1, int filterip=1) -> cpermVector
    generateDoubleConferenceExtensions(array_link al, conference_t ct, int verbose=1, int filtersymm=1) -> cpermVector
    generateDoubleConferenceExtensions(array_link al, conference_t ct, int verbose=1) -> cpermVector
    generateDoubleConferenceExtensions(array_link al, conference_t ct) -> cpermVector

    std::vector<cperm> generateDoubleConferenceExtensions(const array_link
    &al, const conference_t &ct, int verbose=1, int filtersymm=1, int
    filterip=1, int filterJ3=0, int filtersymminline=1) 
    """
    return _oalib.generateDoubleConferenceExtensions(al, ct, verbose, filtersymm, filterip, filterJ3, filtersymminline)

def generateSingleConferenceExtensions(al, ct, kz, verbose, filtersymm, filterj2, filterj3, filtersymminline):
    """generateSingleConferenceExtensions(array_link al, conference_t ct, int kz, int verbose, int filtersymm, int filterj2, int filterj3, int filtersymminline) -> cpermVector"""
    return _oalib.generateSingleConferenceExtensions(al, ct, kz, verbose, filtersymm, filterj2, filterj3, filtersymminline)

def maxz(al, k=-1):
    """
    maxz(array_link al, int k=-1) -> int
    maxz(array_link al) -> int

    int maxz(const array_link &al, int k=-1)

    return max position of zero in array, returns -1 if no zero is found

    The parameter k specifies the column to search in. For k=-1 all
    columns are searched. 
    """
    return _oalib.maxz(al, k)

def compareLMC0(alL, alR):
    """
    compareLMC0(array_link alL, array_link alR) -> bool

    bool compareLMC0(const array_link
    &alL, const array_link &alR)

    Return true of the array is smaller in LMC-0 ordering 
    """
    return _oalib.compareLMC0(alL, alR)

def sortLMC0(lst):
    """
    sortLMC0(arraylist_t lst) -> arraylist_t

    arraylist_t sortLMC0(const
    arraylist_t &lst)

    sort list of arrays according to LMC-0 ordering 
    """
    return _oalib.sortLMC0(lst)

def LMC0checkDC(al, verbose=0):
    """
    LMC0checkDC(array_link al, int verbose=0) -> lmc_t
    LMC0checkDC(array_link al) -> lmc_t
    """
    return _oalib.LMC0checkDC(al, verbose)

def LMC0check(al, verbose=0):
    """
    LMC0check(array_link al, int verbose=0) -> lmc_t
    LMC0check(array_link al) -> lmc_t

    lmc_t LMC0check(const array_link
    &al, int verbose=0)

    check if array is in LM0 form 
    """
    return _oalib.LMC0check(al, verbose)

def isConferenceFoldover(al, verbose=0):
    """
    isConferenceFoldover(array_link al, int verbose=0) -> bool
    isConferenceFoldover(array_link al) -> bool

    bool
    isConferenceFoldover(const array_link &al, int verbose=0)

    return true if the design is a foldover array 
    """
    return _oalib.isConferenceFoldover(al, verbose)

def ipcheck(col, al, cstart=2, verbose=0):
    """
    ipcheck(charVector col, array_link al, int cstart=2, int verbose=0) -> int
    ipcheck(charVector col, array_link al, int cstart=2) -> int
    ipcheck(charVector col, array_link al) -> int

    int ipcheck(const cperm &col, const
    array_link &al, int cstart=2, int verbose=0) 
    """
    return _oalib.ipcheck(col, al, cstart, verbose)

def minz(al, k):
    """
    minz(array_link al, int k) -> int

    int minz(const array_link &al, int k)

    return minimal position of zero in design 
    """
    return _oalib.minz(al, k)
class DconferenceFilter(object):
    """


    class to filter designs

    C++ includes: conference.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    als = _swig_property(_oalib.DconferenceFilter_als_get, _oalib.DconferenceFilter_als_set)
    filtersymm = _swig_property(_oalib.DconferenceFilter_filtersymm_get, _oalib.DconferenceFilter_filtersymm_set)
    filterj2 = _swig_property(_oalib.DconferenceFilter_filterj2_get, _oalib.DconferenceFilter_filterj2_set)
    filterj3 = _swig_property(_oalib.DconferenceFilter_filterj3_get, _oalib.DconferenceFilter_filterj3_set)
    filterfirst = _swig_property(_oalib.DconferenceFilter_filterfirst_get, _oalib.DconferenceFilter_filterfirst_set)
    filterzero = _swig_property(_oalib.DconferenceFilter_filterzero_get, _oalib.DconferenceFilter_filterzero_set)
    ngood = _swig_property(_oalib.DconferenceFilter_ngood_get, _oalib.DconferenceFilter_ngood_set)
    inline_row = _swig_property(_oalib.DconferenceFilter_inline_row_get, _oalib.DconferenceFilter_inline_row_set)
    sd = _swig_property(_oalib.DconferenceFilter_sd_get, _oalib.DconferenceFilter_sd_set)

    def __init__(self, _als, filtersymm_, filterj2_, filterj3_=1):
        """
        __init__(DconferenceFilter self, array_link _als, int filtersymm_, int filterj2_, int filterj3_=1) -> DconferenceFilter
        __init__(DconferenceFilter self, array_link _als, int filtersymm_, int filterj2_) -> DconferenceFilter

        DconferenceFilter::DconferenceFilter(const array_link &_als, int
        filtersymm_, int filterj2_, int filterj3_=1) 
        """
        this = _oalib.new_DconferenceFilter(_als, filtersymm_, filterj2_, filterj3_)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def show(self):
        """show(DconferenceFilter self)"""
        return _oalib.DconferenceFilter_show(self)


    def filterList(self, lst, verbose=0):
        """
        filterList(DconferenceFilter self, cpermVector lst, int verbose=0) -> cpermVector
        filterList(DconferenceFilter self, cpermVector lst) -> cpermVector

        std::vector<cperm> DconferenceFilter::filterList(const std::vector<
        cperm > &lst, int verbose=0) const

        filter a list of cperms using the filter method 
        """
        return _oalib.DconferenceFilter_filterList(self, lst, verbose)


    def filterListJ2last(self, lst):
        """
        filterListJ2last(DconferenceFilter self, cpermVector lst) -> cpermVector

        std::vector<cperm> DconferenceFilter::filterListJ2last(const
        std::vector< cperm > &lst) const 
        """
        return _oalib.DconferenceFilter_filterListJ2last(self, lst)


    def filterListZero(self, lst):
        """
        filterListZero(DconferenceFilter self, cpermVector lst) -> cpermVector

        std::vector<cperm> DconferenceFilter::filterListZero(const
        std::vector< cperm > &lst) const

        filter a list of cperms using the filterZero method 
        """
        return _oalib.DconferenceFilter_filterListZero(self, lst)


    def filter(self, c):
        """
        filter(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filter(const cperm &c) const

        return True of the extension satisfies all checks 
        """
        return _oalib.DconferenceFilter_filter(self, c)


    def filterJpartial(self, c, r):
        """
        filterJpartial(DconferenceFilter self, charVector c, int r) -> bool

        bool
        DconferenceFilter::filterJpartial(const cperm &c, int r) const

        filter on partial column (only last col) 
        """
        return _oalib.DconferenceFilter_filterJpartial(self, c, r)


    def filterJ(self, c, j2start=0):
        """
        filterJ(DconferenceFilter self, charVector c, int j2start=0) -> bool
        filterJ(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ(const cperm &c, int j2start=0) const

        return True of the extension satisfies all J-characteristic checks 
        """
        return _oalib.DconferenceFilter_filterJ(self, c, j2start)


    def filterJlast(self, c, j2start=0):
        """
        filterJlast(DconferenceFilter self, charVector c, int j2start=0) -> bool
        filterJlast(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJlast(const cperm &c, int j2start=0) const

        return True of the extension satisfies all J-characteristic checks for
        the last columns 
        """
        return _oalib.DconferenceFilter_filterJlast(self, c, j2start)


    def filterReason(self, c):
        """
        filterReason(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterReason(const cperm &c) const

        return True of the extension satisfies all checks 
        """
        return _oalib.DconferenceFilter_filterReason(self, c)


    def filterJ3(self, c):
        """
        filterJ3(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ3(const cperm &c) const

        return True of the candidate satisfies the J3 check 
        """
        return _oalib.DconferenceFilter_filterJ3(self, c)


    def filterJ3s(self, c, idxstart):
        """
        filterJ3s(DconferenceFilter self, charVector c, int idxstart) -> bool

        bool
        DconferenceFilter::filterJ3s(const cperm &c, int idxstart) const

        return True of the candidate satisfies the J3 check for specified
        pairs 
        """
        return _oalib.DconferenceFilter_filterJ3s(self, c, idxstart)


    def filterJ3r(self, c):
        """
        filterJ3r(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ3r(const cperm &c) const

        return True of the candidate satisfies the J3 check 
        """
        return _oalib.DconferenceFilter_filterJ3r(self, c)


    def filterJ3inline(self, c):
        """
        filterJ3inline(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ3inline(const cperm &c) const

        return True of the candidate satisfies the J3 check 
        """
        return _oalib.DconferenceFilter_filterJ3inline(self, c)


    def filterSymmetry(self, c):
        """
        filterSymmetry(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterSymmetry(const cperm &c) const

        return True of the candidate satisfies the symmetry check 
        """
        return _oalib.DconferenceFilter_filterSymmetry(self, c)


    def filterJ2(self, c):
        """
        filterJ2(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ2(const cperm &c) const

        return True of the candidate extension satisfies the J2 check 
        """
        return _oalib.DconferenceFilter_filterJ2(self, c)


    def filterJ2last(self, c):
        """
        filterJ2last(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterJ2last(const cperm &c) const

        return True of the candidate extension satisfies the J2 check for the
        last column of the array checked against 
        """
        return _oalib.DconferenceFilter_filterJ2last(self, c)


    def filterZero(self, c):
        """
        filterZero(DconferenceFilter self, charVector c) -> bool

        bool
        DconferenceFilter::filterZero(const cperm &c) const

        return True of the candidate extension satisfies the zero 
        """
        return _oalib.DconferenceFilter_filterZero(self, c)

    __swig_destroy__ = _oalib.delete_DconferenceFilter
    __del__ = lambda self: None
DconferenceFilter_swigregister = _oalib.DconferenceFilter_swigregister
DconferenceFilter_swigregister(DconferenceFilter)


def generateDoubleConferenceExtensionsInflate(al, ct, verbose, filterj2, filterj3, kstart=2):
    """
    generateDoubleConferenceExtensionsInflate(array_link al, conference_t ct, int verbose, int filterj2, int filterj3, int kstart=2) -> cpermVector
    generateDoubleConferenceExtensionsInflate(array_link al, conference_t ct, int verbose, int filterj2, int filterj3) -> cpermVector

    std::vector<cperm> generateDoubleConferenceExtensionsInflate(const
    array_link &al, const conference_t &ct, int verbose, int filterj2, int
    filterj3, int kstart=2) 
    """
    return _oalib.generateDoubleConferenceExtensionsInflate(al, ct, verbose, filterj2, filterj3, kstart)

def inflateCandidateExtension(basecandidate, als, alsg, check_indices, ct, verbose, filter):
    """
    inflateCandidateExtension(charVector basecandidate, array_link als, symmetry_group alsg, intVector check_indices, conference_t ct, int verbose, DconferenceFilter filter) -> cpermVector

    std::vector<cperm>
    inflateCandidateExtension(const cperm &basecandidate, const array_link
    &als, const symmetry_group &alsg, const std::vector< int >
    &check_indices, const conference_t &ct, int verbose, const
    DconferenceFilter &filter) 
    """
    return _oalib.inflateCandidateExtension(basecandidate, als, alsg, check_indices, ct, verbose, filter)

def setdtsymm(arg1):
    """setdtsymm(double arg1)"""
    return _oalib.setdtsymm(arg1)

def getdtsymm():
    """getdtsymm() -> double"""
    return _oalib.getdtsymm()

def setdtlmc(arg1):
    """setdtlmc(double arg1)"""
    return _oalib.setdtlmc(arg1)

def getdtlmc():
    """getdtlmc() -> double"""
    return _oalib.getdtlmc()

def adddtlmc(arg1):
    """adddtlmc(double arg1)"""
    return _oalib.adddtlmc(arg1)

def extend_array_dynamic(*args):
    """
    extend_array_dynamic(arraylist_t alist, arraydata_t adx, OAextend oaextend, arraylist_t earrays, vector_vector_double edata, int kfinal, double Afinal, int directcheck, int verbose=1) -> int
    extend_array_dynamic(arraylist_t alist, arraydata_t adx, OAextend oaextend, arraylist_t earrays, vector_vector_double edata, int kfinal, double Afinal, int directcheck) -> int
    extend_array_dynamic(array_link al, arraydata_t adx, OAextend oaextend, arraylist_t earrays, vector_vector_double edata, dextend_t dextend, int kfinal, double Afinal, int rs, int verbose=1) -> int
    extend_array_dynamic(array_link al, arraydata_t adx, OAextend oaextend, arraylist_t earrays, vector_vector_double edata, dextend_t dextend, int kfinal, double Afinal, int rs) -> int
    """
    return _oalib.extend_array_dynamic(*args)

def extend_array_large(origarray, fullad, extensioncol, extensions, oaextend, largecol):
    """extend_array_large(carray_t * origarray, arraydata_t fullad, colindex_t extensioncol, arraylist_t extensions, OAextend oaextend, int largecol) -> int"""
    return _oalib.extend_array_large(origarray, fullad, extensioncol, extensions, oaextend, largecol)

def extend_array_el(al, fullad, extensions, oaextend, verbose=1):
    """
    extend_array_el(array_link al, arraydata_t fullad, arraylist_t extensions, OAextend oaextend, int verbose=1) -> int
    extend_array_el(array_link al, arraydata_t fullad, arraylist_t extensions, OAextend oaextend) -> int
    """
    return _oalib.extend_array_el(al, fullad, extensions, oaextend, verbose)
class pairDoptimize(object):
    """Proxy of C++ std::pair<(std::vector<(std::vector<(double)>)>,arraylist_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(std::pair<(std::vector<(std::vector<(double)>)>,arraylist_t)> self) -> pairDoptimize
        __init__(std::pair<(std::vector<(std::vector<(double)>)>,arraylist_t)> self, vector_vector_double first, arraylist_t second) -> pairDoptimize
        __init__(std::pair<(std::vector<(std::vector<(double)>)>,arraylist_t)> self, pairDoptimize p) -> pairDoptimize
        """
        this = _oalib.new_pairDoptimize(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    first = _swig_property(_oalib.pairDoptimize_first_get, _oalib.pairDoptimize_first_set)
    second = _swig_property(_oalib.pairDoptimize_second_get, _oalib.pairDoptimize_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _oalib.delete_pairDoptimize
    __del__ = lambda self: None
pairDoptimize_swigregister = _oalib.pairDoptimize_swigregister
pairDoptimize_swigregister(pairDoptimize)

class pairGraphColors(object):
    """Proxy of C++ std::pair<(array_link,std::vector<(int)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(std::pair<(array_link,std::vector<(int)>)> self) -> pairGraphColors
        __init__(std::pair<(array_link,std::vector<(int)>)> self, array_link first, intVector second) -> pairGraphColors
        __init__(std::pair<(array_link,std::vector<(int)>)> self, pairGraphColors p) -> pairGraphColors
        """
        this = _oalib.new_pairGraphColors(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    first = _swig_property(_oalib.pairGraphColors_first_get, _oalib.pairGraphColors_first_set)
    second = _swig_property(_oalib.pairGraphColors_second_get, _oalib.pairGraphColors_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _oalib.delete_pairGraphColors
    __del__ = lambda self: None
pairGraphColors_swigregister = _oalib.pairGraphColors_swigregister
pairGraphColors_swigregister(pairGraphColors)

class mvalue_t_long(object):
    """


    Multi-value type.

    This object represents a multi-valued object. The objects are ordered
    using lexicographic ordering.

    C++ includes: mathtools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    v = _swig_property(_oalib.mvalue_t_long_v_get, _oalib.mvalue_t_long_v_set)
    HIGH = _oalib.mvalue_t_long_HIGH
    LOW = _oalib.mvalue_t_long_LOW
    d = _swig_property(_oalib.mvalue_t_long_d_get, _oalib.mvalue_t_long_d_set)
    __swig_destroy__ = _oalib.delete_mvalue_t_long
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(mvalue_t<(long)> self) -> mvalue_t_long
        __init__(mvalue_t<(long)> self, long m, mvalue_t< long >::direction_t dd) -> mvalue_t_long
        __init__(mvalue_t<(long)> self, long m) -> mvalue_t_long
        __init__(mvalue_t<(long)> self, longVector vv, mvalue_t< long >::direction_t dd) -> mvalue_t_long
        __init__(mvalue_t<(long)> self, longVector vv) -> mvalue_t_long

        mvalue_t< NumericType
        >::mvalue_t(std::vector< T > vv, direction_t dd=HIGH) 
        """
        this = _oalib.new_mvalue_t_long(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def size(self):
        """
        size(mvalue_t_long self) -> size_t

        size_t mvalue_t< NumericType
        >::size() const 
        """
        return _oalib.mvalue_t_long_size(self)


    def __eq__(self, rhs):
        """__eq__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___eq__(self, rhs)


    def __ne__(self, rhs):
        """__ne__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___ne__(self, rhs)


    def __le__(self, rhs):
        """__le__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___le__(self, rhs)


    def __lt__(self, rhs):
        """__lt__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___lt__(self, rhs)


    def __gt__(self, rhs):
        """__gt__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___gt__(self, rhs)


    def __ge__(self, rhs):
        """__ge__(mvalue_t_long self, mvalue_t_long rhs) -> bool"""
        return _oalib.mvalue_t_long___ge__(self, rhs)


    def show_integer(self):
        """
        show_integer(mvalue_t_long self)

        void mvalue_t<
        NumericType >::show_integer() const 
        """
        return _oalib.mvalue_t_long_show_integer(self)


    def __repr__x(self):
        """__repr__x(mvalue_t_long self) -> std::string"""
        return _oalib.mvalue_t_long___repr__x(self)

mvalue_t_long_swigregister = _oalib.mvalue_t_long_swigregister
mvalue_t_long_swigregister(mvalue_t_long)

class mvalue_t_double(object):
    """


    Multi-value type.

    This object represents a multi-valued object. The objects are ordered
    using lexicographic ordering.

    C++ includes: mathtools.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    v = _swig_property(_oalib.mvalue_t_double_v_get, _oalib.mvalue_t_double_v_set)
    HIGH = _oalib.mvalue_t_double_HIGH
    LOW = _oalib.mvalue_t_double_LOW
    d = _swig_property(_oalib.mvalue_t_double_d_get, _oalib.mvalue_t_double_d_set)
    __swig_destroy__ = _oalib.delete_mvalue_t_double
    __del__ = lambda self: None

    def __init__(self, *args):
        """
        __init__(mvalue_t<(double)> self) -> mvalue_t_double
        __init__(mvalue_t<(double)> self, double m, mvalue_t< double >::direction_t dd) -> mvalue_t_double
        __init__(mvalue_t<(double)> self, double m) -> mvalue_t_double
        __init__(mvalue_t<(double)> self, doubleVector vv, mvalue_t< double >::direction_t dd) -> mvalue_t_double
        __init__(mvalue_t<(double)> self, doubleVector vv) -> mvalue_t_double

        mvalue_t< NumericType
        >::mvalue_t(std::vector< T > vv, direction_t dd=HIGH) 
        """
        this = _oalib.new_mvalue_t_double(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def size(self):
        """
        size(mvalue_t_double self) -> size_t

        size_t mvalue_t< NumericType
        >::size() const 
        """
        return _oalib.mvalue_t_double_size(self)


    def __eq__(self, rhs):
        """__eq__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___eq__(self, rhs)


    def __ne__(self, rhs):
        """__ne__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___ne__(self, rhs)


    def __le__(self, rhs):
        """__le__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___le__(self, rhs)


    def __lt__(self, rhs):
        """__lt__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___lt__(self, rhs)


    def __gt__(self, rhs):
        """__gt__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___gt__(self, rhs)


    def __ge__(self, rhs):
        """__ge__(mvalue_t_double self, mvalue_t_double rhs) -> bool"""
        return _oalib.mvalue_t_double___ge__(self, rhs)


    def show_integer(self):
        """
        show_integer(mvalue_t_double self)

        void mvalue_t<
        NumericType >::show_integer() const 
        """
        return _oalib.mvalue_t_double_show_integer(self)


    def __repr__x(self):
        """__repr__x(mvalue_t_double self) -> std::string"""
        return _oalib.mvalue_t_double___repr__x(self)

mvalue_t_double_swigregister = _oalib.mvalue_t_double_swigregister
mvalue_t_double_swigregister(mvalue_t_double)

class ParetoLongLong(object):
    """


    Class to the calculate Pareto optimal elements.

    The class is templated by the type of values to be compared and an
    index type. The index type is used to index the elements.

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    verbose = _swig_property(_oalib.ParetoLongLong_verbose_get, _oalib.ParetoLongLong_verbose_set)
    elements = _swig_property(_oalib.ParetoLongLong_elements_get, _oalib.ParetoLongLong_elements_set)

    def __init__(self):
        """
        __init__(Pareto<(long,long)> self) -> ParetoLongLong

        Pareto< ValueType, IndexType
        >::Pareto()

        constructor 
        """
        this = _oalib.new_ParetoLongLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoLongLong
    __del__ = lambda self: None

    def number(self):
        """
        number(ParetoLongLong self) -> int

        int Pareto< ValueType,
        IndexType >::number() const

        return the total number of Pareto optimal values 
        """
        return _oalib.ParetoLongLong_number(self)


    def numberindices(self):
        """
        numberindices(ParetoLongLong self) -> int

        int Pareto< ValueType,
        IndexType >::numberindices() const

        return the toal number Pareto optimal objects 
        """
        return _oalib.ParetoLongLong_numberindices(self)


    def __repr__(self):
        """
        __repr__(ParetoLongLong self) -> std::string

        std::string Pareto<
        ValueType, IndexType >::__repr__() const 
        """
        return _oalib.ParetoLongLong___repr__(self)


    def showvalue(p):
        """showvalue(longVector p)"""
        return _oalib.ParetoLongLong_showvalue(p)

    showvalue = staticmethod(showvalue)

    def show(self, verbose=1):
        """
        show(ParetoLongLong self, int verbose=1)
        show(ParetoLongLong self)

        void Pareto< ValueType,
        IndexType >::show(int verbose=1)

        show the current set of Pareto optimal elements 
        """
        return _oalib.ParetoLongLong_show(self, verbose)


    def allindicesdeque(self):
        """
        allindicesdeque(ParetoLongLong self) -> longDeque

        std::deque<IndexType>
        Pareto< ValueType, IndexType >::allindicesdeque() const

        return all indices of the Pareto optimal elements as a std::deque 
        """
        return _oalib.ParetoLongLong_allindicesdeque(self)


    def allindices(self):
        """
        allindices(ParetoLongLong self) -> longVector

        std::vector<IndexType>
        Pareto< ValueType, IndexType >::allindices() const

        return all indices of the Pareto optimal elements 
        """
        return _oalib.ParetoLongLong_allindices(self)


    def allvalues(self):
        """
        allvalues(ParetoLongLong self) -> std::vector< Pareto< long,long >::pValue,std::allocator< Pareto< long,long >::pValue > >

        std::vector<pValue> Pareto<
        ValueType, IndexType >::allvalues() const

        return all Paretop optimal elements 
        """
        return _oalib.ParetoLongLong_allvalues(self)


    def addvalue(self, val, idx):
        """
        addvalue(ParetoLongLong self, longVector val, long const idx) -> bool

        bool Pareto< ValueType,
        IndexType >::addvalue(const pValue val, const IndexType idx)

        add a new element 
        """
        return _oalib.ParetoLongLong_addvalue(self, val, idx)

ParetoLongLong_swigregister = _oalib.ParetoLongLong_swigregister
ParetoLongLong_swigregister(ParetoLongLong)

def ParetoLongLong_showvalue(p):
    """ParetoLongLong_showvalue(longVector p)"""
    return _oalib.ParetoLongLong_showvalue(p)

class ParetoMultiLongLong(object):
    """


    Class to the calculate Pareto optimal elements.

    The class is templated by the type of values to be compared and an
    index type. The index type is used to index the elements.

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    verbose = _swig_property(_oalib.ParetoMultiLongLong_verbose_get, _oalib.ParetoMultiLongLong_verbose_set)
    elements = _swig_property(_oalib.ParetoMultiLongLong_elements_get, _oalib.ParetoMultiLongLong_elements_set)

    def __init__(self):
        """
        __init__(Pareto<(mvalue_t<(long)>,long)> self) -> ParetoMultiLongLong

        Pareto< ValueType, IndexType
        >::Pareto()

        constructor 
        """
        this = _oalib.new_ParetoMultiLongLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoMultiLongLong
    __del__ = lambda self: None

    def number(self):
        """
        number(ParetoMultiLongLong self) -> int

        int Pareto< ValueType,
        IndexType >::number() const

        return the total number of Pareto optimal values 
        """
        return _oalib.ParetoMultiLongLong_number(self)


    def numberindices(self):
        """
        numberindices(ParetoMultiLongLong self) -> int

        int Pareto< ValueType,
        IndexType >::numberindices() const

        return the toal number Pareto optimal objects 
        """
        return _oalib.ParetoMultiLongLong_numberindices(self)


    def __repr__(self):
        """
        __repr__(ParetoMultiLongLong self) -> std::string

        std::string Pareto<
        ValueType, IndexType >::__repr__() const 
        """
        return _oalib.ParetoMultiLongLong___repr__(self)


    def showvalue(p):
        """showvalue(vector_mvalue_t_long p)"""
        return _oalib.ParetoMultiLongLong_showvalue(p)

    showvalue = staticmethod(showvalue)

    def show(self, verbose=1):
        """
        show(ParetoMultiLongLong self, int verbose=1)
        show(ParetoMultiLongLong self)

        void Pareto< ValueType,
        IndexType >::show(int verbose=1)

        show the current set of Pareto optimal elements 
        """
        return _oalib.ParetoMultiLongLong_show(self, verbose)


    def allindicesdeque(self):
        """
        allindicesdeque(ParetoMultiLongLong self) -> longDeque

        std::deque<IndexType>
        Pareto< ValueType, IndexType >::allindicesdeque() const

        return all indices of the Pareto optimal elements as a std::deque 
        """
        return _oalib.ParetoMultiLongLong_allindicesdeque(self)


    def allindices(self):
        """
        allindices(ParetoMultiLongLong self) -> longVector

        std::vector<IndexType>
        Pareto< ValueType, IndexType >::allindices() const

        return all indices of the Pareto optimal elements 
        """
        return _oalib.ParetoMultiLongLong_allindices(self)


    def allvalues(self):
        """
        allvalues(ParetoMultiLongLong self) -> std::vector< Pareto< mvalue_t< long >,long >::pValue,std::allocator< Pareto< mvalue_t< long >,long >::pValue > >

        std::vector<pValue> Pareto<
        ValueType, IndexType >::allvalues() const

        return all Paretop optimal elements 
        """
        return _oalib.ParetoMultiLongLong_allvalues(self)


    def addvalue(self, val, idx):
        """
        addvalue(ParetoMultiLongLong self, vector_mvalue_t_long val, long const idx) -> bool

        bool Pareto< ValueType,
        IndexType >::addvalue(const pValue val, const IndexType idx)

        add a new element 
        """
        return _oalib.ParetoMultiLongLong_addvalue(self, val, idx)

ParetoMultiLongLong_swigregister = _oalib.ParetoMultiLongLong_swigregister
ParetoMultiLongLong_swigregister(ParetoMultiLongLong)

def ParetoMultiLongLong_showvalue(p):
    """ParetoMultiLongLong_showvalue(vector_mvalue_t_long p)"""
    return _oalib.ParetoMultiLongLong_showvalue(p)

class ParetoMultiDoubleLong(object):
    """


    Class to the calculate Pareto optimal elements.

    The class is templated by the type of values to be compared and an
    index type. The index type is used to index the elements.

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    verbose = _swig_property(_oalib.ParetoMultiDoubleLong_verbose_get, _oalib.ParetoMultiDoubleLong_verbose_set)
    elements = _swig_property(_oalib.ParetoMultiDoubleLong_elements_get, _oalib.ParetoMultiDoubleLong_elements_set)

    def __init__(self):
        """
        __init__(Pareto<(mvalue_t<(double)>,long)> self) -> ParetoMultiDoubleLong

        Pareto< ValueType, IndexType
        >::Pareto()

        constructor 
        """
        this = _oalib.new_ParetoMultiDoubleLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoMultiDoubleLong
    __del__ = lambda self: None

    def number(self):
        """
        number(ParetoMultiDoubleLong self) -> int

        int Pareto< ValueType,
        IndexType >::number() const

        return the total number of Pareto optimal values 
        """
        return _oalib.ParetoMultiDoubleLong_number(self)


    def numberindices(self):
        """
        numberindices(ParetoMultiDoubleLong self) -> int

        int Pareto< ValueType,
        IndexType >::numberindices() const

        return the toal number Pareto optimal objects 
        """
        return _oalib.ParetoMultiDoubleLong_numberindices(self)


    def __repr__(self):
        """
        __repr__(ParetoMultiDoubleLong self) -> std::string

        std::string Pareto<
        ValueType, IndexType >::__repr__() const 
        """
        return _oalib.ParetoMultiDoubleLong___repr__(self)


    def showvalue(p):
        """showvalue(vector_mvalue_t_double p)"""
        return _oalib.ParetoMultiDoubleLong_showvalue(p)

    showvalue = staticmethod(showvalue)

    def show(self, verbose=1):
        """
        show(ParetoMultiDoubleLong self, int verbose=1)
        show(ParetoMultiDoubleLong self)

        void Pareto< ValueType,
        IndexType >::show(int verbose=1)

        show the current set of Pareto optimal elements 
        """
        return _oalib.ParetoMultiDoubleLong_show(self, verbose)


    def allindicesdeque(self):
        """
        allindicesdeque(ParetoMultiDoubleLong self) -> longDeque

        std::deque<IndexType>
        Pareto< ValueType, IndexType >::allindicesdeque() const

        return all indices of the Pareto optimal elements as a std::deque 
        """
        return _oalib.ParetoMultiDoubleLong_allindicesdeque(self)


    def allindices(self):
        """
        allindices(ParetoMultiDoubleLong self) -> longVector

        std::vector<IndexType>
        Pareto< ValueType, IndexType >::allindices() const

        return all indices of the Pareto optimal elements 
        """
        return _oalib.ParetoMultiDoubleLong_allindices(self)


    def allvalues(self):
        """
        allvalues(ParetoMultiDoubleLong self) -> std::vector< Pareto< mvalue_t< double >,long >::pValue,std::allocator< Pareto< mvalue_t< double >,long >::pValue > >

        std::vector<pValue> Pareto<
        ValueType, IndexType >::allvalues() const

        return all Paretop optimal elements 
        """
        return _oalib.ParetoMultiDoubleLong_allvalues(self)


    def addvalue(self, val, idx):
        """
        addvalue(ParetoMultiDoubleLong self, vector_mvalue_t_double val, long const idx) -> bool

        bool Pareto< ValueType,
        IndexType >::addvalue(const pValue val, const IndexType idx)

        add a new element 
        """
        return _oalib.ParetoMultiDoubleLong_addvalue(self, val, idx)

ParetoMultiDoubleLong_swigregister = _oalib.ParetoMultiDoubleLong_swigregister
ParetoMultiDoubleLong_swigregister(ParetoMultiDoubleLong)

def ParetoMultiDoubleLong_showvalue(p):
    """ParetoMultiDoubleLong_showvalue(vector_mvalue_t_double p)"""
    return _oalib.ParetoMultiDoubleLong_showvalue(p)

class ParetoDoubleLong(object):
    """


    Class to the calculate Pareto optimal elements.

    The class is templated by the type of values to be compared and an
    index type. The index type is used to index the elements.

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    verbose = _swig_property(_oalib.ParetoDoubleLong_verbose_get, _oalib.ParetoDoubleLong_verbose_set)
    elements = _swig_property(_oalib.ParetoDoubleLong_elements_get, _oalib.ParetoDoubleLong_elements_set)

    def __init__(self):
        """
        __init__(Pareto<(double,long)> self) -> ParetoDoubleLong

        Pareto< ValueType, IndexType
        >::Pareto()

        constructor 
        """
        this = _oalib.new_ParetoDoubleLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoDoubleLong
    __del__ = lambda self: None

    def number(self):
        """
        number(ParetoDoubleLong self) -> int

        int Pareto< ValueType,
        IndexType >::number() const

        return the total number of Pareto optimal values 
        """
        return _oalib.ParetoDoubleLong_number(self)


    def numberindices(self):
        """
        numberindices(ParetoDoubleLong self) -> int

        int Pareto< ValueType,
        IndexType >::numberindices() const

        return the toal number Pareto optimal objects 
        """
        return _oalib.ParetoDoubleLong_numberindices(self)


    def __repr__(self):
        """
        __repr__(ParetoDoubleLong self) -> std::string

        std::string Pareto<
        ValueType, IndexType >::__repr__() const 
        """
        return _oalib.ParetoDoubleLong___repr__(self)


    def showvalue(p):
        """showvalue(doubleVector p)"""
        return _oalib.ParetoDoubleLong_showvalue(p)

    showvalue = staticmethod(showvalue)

    def show(self, verbose=1):
        """
        show(ParetoDoubleLong self, int verbose=1)
        show(ParetoDoubleLong self)

        void Pareto< ValueType,
        IndexType >::show(int verbose=1)

        show the current set of Pareto optimal elements 
        """
        return _oalib.ParetoDoubleLong_show(self, verbose)


    def allindicesdeque(self):
        """
        allindicesdeque(ParetoDoubleLong self) -> longDeque

        std::deque<IndexType>
        Pareto< ValueType, IndexType >::allindicesdeque() const

        return all indices of the Pareto optimal elements as a std::deque 
        """
        return _oalib.ParetoDoubleLong_allindicesdeque(self)


    def allindices(self):
        """
        allindices(ParetoDoubleLong self) -> longVector

        std::vector<IndexType>
        Pareto< ValueType, IndexType >::allindices() const

        return all indices of the Pareto optimal elements 
        """
        return _oalib.ParetoDoubleLong_allindices(self)


    def allvalues(self):
        """
        allvalues(ParetoDoubleLong self) -> vector_vector_double

        std::vector<pValue> Pareto<
        ValueType, IndexType >::allvalues() const

        return all Paretop optimal elements 
        """
        return _oalib.ParetoDoubleLong_allvalues(self)


    def addvalue(self, val, idx):
        """
        addvalue(ParetoDoubleLong self, doubleVector val, long const idx) -> bool

        bool Pareto< ValueType,
        IndexType >::addvalue(const pValue val, const IndexType idx)

        add a new element 
        """
        return _oalib.ParetoDoubleLong_addvalue(self, val, idx)

ParetoDoubleLong_swigregister = _oalib.ParetoDoubleLong_swigregister
ParetoDoubleLong_swigregister(ParetoDoubleLong)

def ParetoDoubleLong_showvalue(p):
    """ParetoDoubleLong_showvalue(doubleVector p)"""
    return _oalib.ParetoDoubleLong_showvalue(p)

class ParetoElementLong(object):
    """


    helper class for the Pareto class

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    value = _swig_property(_oalib.ParetoElementLong_value_get, _oalib.ParetoElementLong_value_set)
    indices = _swig_property(_oalib.ParetoElementLong_indices_get, _oalib.ParetoElementLong_indices_set)

    def dominates(self, v):
        """
        dominates(ParetoElementLong self, vector_mvalue_t_long v) -> bool

        bool
        pareto_element< ValueType, IndexType >::dominates(pValue v)

        return true of the argument element dominates this value 
        """
        return _oalib.ParetoElementLong_dominates(self, v)


    def isdominated(self, v):
        """
        isdominated(ParetoElementLong self, vector_mvalue_t_long v) -> bool

        bool
        pareto_element< ValueType, IndexType >::isdominated(pValue v) 
        """
        return _oalib.ParetoElementLong_isdominated(self, v)


    def equal(self, v):
        """
        equal(ParetoElementLong self, vector_mvalue_t_long v) -> bool

        bool pareto_element<
        ValueType, IndexType >::equal(pValue v)

        return true of the argument element is equal to this element 
        """
        return _oalib.ParetoElementLong_equal(self, v)


    def __init__(self):
        """
        __init__(pareto_element<(mvalue_t<(long)>,long)> self) -> ParetoElementLong



        helper class for the Pareto class

        C++ includes: pareto.h 
        """
        this = _oalib.new_ParetoElementLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoElementLong
    __del__ = lambda self: None
ParetoElementLong_swigregister = _oalib.ParetoElementLong_swigregister
ParetoElementLong_swigregister(ParetoElementLong)

class ParetoMElementLong(object):
    """


    helper class for the Pareto class

    C++ includes: pareto.h 
    """

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    value = _swig_property(_oalib.ParetoMElementLong_value_get, _oalib.ParetoMElementLong_value_set)
    indices = _swig_property(_oalib.ParetoMElementLong_indices_get, _oalib.ParetoMElementLong_indices_set)

    def dominates(self, v):
        """
        dominates(ParetoMElementLong self, vector_mvalue_t_long v) -> bool

        bool
        pareto_element< ValueType, IndexType >::dominates(pValue v)

        return true of the argument element dominates this value 
        """
        return _oalib.ParetoMElementLong_dominates(self, v)


    def isdominated(self, v):
        """
        isdominated(ParetoMElementLong self, vector_mvalue_t_long v) -> bool

        bool
        pareto_element< ValueType, IndexType >::isdominated(pValue v) 
        """
        return _oalib.ParetoMElementLong_isdominated(self, v)


    def equal(self, v):
        """
        equal(ParetoMElementLong self, vector_mvalue_t_long v) -> bool

        bool pareto_element<
        ValueType, IndexType >::equal(pValue v)

        return true of the argument element is equal to this element 
        """
        return _oalib.ParetoMElementLong_equal(self, v)


    def __init__(self):
        """
        __init__(pareto_element<(mvalue_t<(long)>,long)> self) -> ParetoMElementLong



        helper class for the Pareto class

        C++ includes: pareto.h 
        """
        this = _oalib.new_ParetoMElementLong()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _oalib.delete_ParetoMElementLong
    __del__ = lambda self: None
ParetoMElementLong_swigregister = _oalib.ParetoMElementLong_swigregister
ParetoMElementLong_swigregister(ParetoMElementLong)

class vector_mvalue_t_double(object):
    """Proxy of C++ std::vector<(mvalue_t<(double)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vector_mvalue_t_double self) -> SwigPyIterator"""
        return _oalib.vector_mvalue_t_double_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vector_mvalue_t_double self) -> bool"""
        return _oalib.vector_mvalue_t_double___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_mvalue_t_double self) -> bool"""
        return _oalib.vector_mvalue_t_double___bool__(self)


    def __len__(self):
        """__len__(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::size_type"""
        return _oalib.vector_mvalue_t_double___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i, std::vector< mvalue_t< double > >::difference_type j) -> vector_mvalue_t_double"""
        return _oalib.vector_mvalue_t_double___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i, std::vector< mvalue_t< double > >::difference_type j)
        __setslice__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i, std::vector< mvalue_t< double > >::difference_type j, vector_mvalue_t_double v)
        """
        return _oalib.vector_mvalue_t_double___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i, std::vector< mvalue_t< double > >::difference_type j)"""
        return _oalib.vector_mvalue_t_double___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i)
        __delitem__(vector_mvalue_t_double self, PySliceObject * slice)
        """
        return _oalib.vector_mvalue_t_double___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_mvalue_t_double self, PySliceObject * slice) -> vector_mvalue_t_double
        __getitem__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i) -> mvalue_t_double
        """
        return _oalib.vector_mvalue_t_double___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_mvalue_t_double self, PySliceObject * slice, vector_mvalue_t_double v)
        __setitem__(vector_mvalue_t_double self, PySliceObject * slice)
        __setitem__(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::difference_type i, mvalue_t_double x)
        """
        return _oalib.vector_mvalue_t_double___setitem__(self, *args)


    def pop(self):
        """pop(vector_mvalue_t_double self) -> mvalue_t_double"""
        return _oalib.vector_mvalue_t_double_pop(self)


    def append(self, x):
        """append(vector_mvalue_t_double self, mvalue_t_double x)"""
        return _oalib.vector_mvalue_t_double_append(self, x)


    def empty(self):
        """empty(vector_mvalue_t_double self) -> bool"""
        return _oalib.vector_mvalue_t_double_empty(self)


    def size(self):
        """size(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::size_type"""
        return _oalib.vector_mvalue_t_double_size(self)


    def swap(self, v):
        """swap(vector_mvalue_t_double self, vector_mvalue_t_double v)"""
        return _oalib.vector_mvalue_t_double_swap(self, v)


    def begin(self):
        """begin(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::iterator"""
        return _oalib.vector_mvalue_t_double_begin(self)


    def end(self):
        """end(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::iterator"""
        return _oalib.vector_mvalue_t_double_end(self)


    def rbegin(self):
        """rbegin(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_double_rbegin(self)


    def rend(self):
        """rend(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_double_rend(self)


    def clear(self):
        """clear(vector_mvalue_t_double self)"""
        return _oalib.vector_mvalue_t_double_clear(self)


    def get_allocator(self):
        """get_allocator(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::allocator_type"""
        return _oalib.vector_mvalue_t_double_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_mvalue_t_double self)"""
        return _oalib.vector_mvalue_t_double_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::iterator pos) -> std::vector< mvalue_t< double > >::iterator
        erase(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::iterator first, std::vector< mvalue_t< double > >::iterator last) -> std::vector< mvalue_t< double > >::iterator
        """
        return _oalib.vector_mvalue_t_double_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(mvalue_t<(double)>)> self) -> vector_mvalue_t_double
        __init__(std::vector<(mvalue_t<(double)>)> self, vector_mvalue_t_double arg2) -> vector_mvalue_t_double
        __init__(std::vector<(mvalue_t<(double)>)> self, std::vector< mvalue_t< double > >::size_type size) -> vector_mvalue_t_double
        __init__(std::vector<(mvalue_t<(double)>)> self, std::vector< mvalue_t< double > >::size_type size, mvalue_t_double value) -> vector_mvalue_t_double
        """
        this = _oalib.new_vector_mvalue_t_double(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_mvalue_t_double self, mvalue_t_double x)"""
        return _oalib.vector_mvalue_t_double_push_back(self, x)


    def front(self):
        """front(vector_mvalue_t_double self) -> mvalue_t_double"""
        return _oalib.vector_mvalue_t_double_front(self)


    def back(self):
        """back(vector_mvalue_t_double self) -> mvalue_t_double"""
        return _oalib.vector_mvalue_t_double_back(self)


    def assign(self, n, x):
        """assign(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::size_type n, mvalue_t_double x)"""
        return _oalib.vector_mvalue_t_double_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::size_type new_size)
        resize(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::size_type new_size, mvalue_t_double x)
        """
        return _oalib.vector_mvalue_t_double_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::iterator pos, mvalue_t_double x) -> std::vector< mvalue_t< double > >::iterator
        insert(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::iterator pos, std::vector< mvalue_t< double > >::size_type n, mvalue_t_double x)
        """
        return _oalib.vector_mvalue_t_double_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_mvalue_t_double self, std::vector< mvalue_t< double > >::size_type n)"""
        return _oalib.vector_mvalue_t_double_reserve(self, n)


    def capacity(self):
        """capacity(vector_mvalue_t_double self) -> std::vector< mvalue_t< double > >::size_type"""
        return _oalib.vector_mvalue_t_double_capacity(self)

    __swig_destroy__ = _oalib.delete_vector_mvalue_t_double
    __del__ = lambda self: None
vector_mvalue_t_double_swigregister = _oalib.vector_mvalue_t_double_swigregister
vector_mvalue_t_double_swigregister(vector_mvalue_t_double)

class vector_mvalue_t_int(object):
    """Proxy of C++ std::vector<(mvalue_t<(int)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vector_mvalue_t_int self) -> SwigPyIterator"""
        return _oalib.vector_mvalue_t_int_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vector_mvalue_t_int self) -> bool"""
        return _oalib.vector_mvalue_t_int___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_mvalue_t_int self) -> bool"""
        return _oalib.vector_mvalue_t_int___bool__(self)


    def __len__(self):
        """__len__(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::size_type"""
        return _oalib.vector_mvalue_t_int___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i, std::vector< mvalue_t< int > >::difference_type j) -> vector_mvalue_t_int"""
        return _oalib.vector_mvalue_t_int___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i, std::vector< mvalue_t< int > >::difference_type j)
        __setslice__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i, std::vector< mvalue_t< int > >::difference_type j, vector_mvalue_t_int v)
        """
        return _oalib.vector_mvalue_t_int___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i, std::vector< mvalue_t< int > >::difference_type j)"""
        return _oalib.vector_mvalue_t_int___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i)
        __delitem__(vector_mvalue_t_int self, PySliceObject * slice)
        """
        return _oalib.vector_mvalue_t_int___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_mvalue_t_int self, PySliceObject * slice) -> vector_mvalue_t_int
        __getitem__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i) -> std::vector< mvalue_t< int > >::value_type const &
        """
        return _oalib.vector_mvalue_t_int___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_mvalue_t_int self, PySliceObject * slice, vector_mvalue_t_int v)
        __setitem__(vector_mvalue_t_int self, PySliceObject * slice)
        __setitem__(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::difference_type i, std::vector< mvalue_t< int > >::value_type const & x)
        """
        return _oalib.vector_mvalue_t_int___setitem__(self, *args)


    def pop(self):
        """pop(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::value_type"""
        return _oalib.vector_mvalue_t_int_pop(self)


    def append(self, x):
        """append(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::value_type const & x)"""
        return _oalib.vector_mvalue_t_int_append(self, x)


    def empty(self):
        """empty(vector_mvalue_t_int self) -> bool"""
        return _oalib.vector_mvalue_t_int_empty(self)


    def size(self):
        """size(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::size_type"""
        return _oalib.vector_mvalue_t_int_size(self)


    def swap(self, v):
        """swap(vector_mvalue_t_int self, vector_mvalue_t_int v)"""
        return _oalib.vector_mvalue_t_int_swap(self, v)


    def begin(self):
        """begin(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::iterator"""
        return _oalib.vector_mvalue_t_int_begin(self)


    def end(self):
        """end(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::iterator"""
        return _oalib.vector_mvalue_t_int_end(self)


    def rbegin(self):
        """rbegin(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_int_rbegin(self)


    def rend(self):
        """rend(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_int_rend(self)


    def clear(self):
        """clear(vector_mvalue_t_int self)"""
        return _oalib.vector_mvalue_t_int_clear(self)


    def get_allocator(self):
        """get_allocator(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::allocator_type"""
        return _oalib.vector_mvalue_t_int_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_mvalue_t_int self)"""
        return _oalib.vector_mvalue_t_int_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::iterator pos) -> std::vector< mvalue_t< int > >::iterator
        erase(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::iterator first, std::vector< mvalue_t< int > >::iterator last) -> std::vector< mvalue_t< int > >::iterator
        """
        return _oalib.vector_mvalue_t_int_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(mvalue_t<(int)>)> self) -> vector_mvalue_t_int
        __init__(std::vector<(mvalue_t<(int)>)> self, vector_mvalue_t_int arg2) -> vector_mvalue_t_int
        __init__(std::vector<(mvalue_t<(int)>)> self, std::vector< mvalue_t< int > >::size_type size) -> vector_mvalue_t_int
        __init__(std::vector<(mvalue_t<(int)>)> self, std::vector< mvalue_t< int > >::size_type size, std::vector< mvalue_t< int > >::value_type const & value) -> vector_mvalue_t_int
        """
        this = _oalib.new_vector_mvalue_t_int(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::value_type const & x)"""
        return _oalib.vector_mvalue_t_int_push_back(self, x)


    def front(self):
        """front(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::value_type const &"""
        return _oalib.vector_mvalue_t_int_front(self)


    def back(self):
        """back(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::value_type const &"""
        return _oalib.vector_mvalue_t_int_back(self)


    def assign(self, n, x):
        """assign(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::size_type n, std::vector< mvalue_t< int > >::value_type const & x)"""
        return _oalib.vector_mvalue_t_int_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::size_type new_size)
        resize(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::size_type new_size, std::vector< mvalue_t< int > >::value_type const & x)
        """
        return _oalib.vector_mvalue_t_int_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::iterator pos, std::vector< mvalue_t< int > >::value_type const & x) -> std::vector< mvalue_t< int > >::iterator
        insert(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::iterator pos, std::vector< mvalue_t< int > >::size_type n, std::vector< mvalue_t< int > >::value_type const & x)
        """
        return _oalib.vector_mvalue_t_int_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_mvalue_t_int self, std::vector< mvalue_t< int > >::size_type n)"""
        return _oalib.vector_mvalue_t_int_reserve(self, n)


    def capacity(self):
        """capacity(vector_mvalue_t_int self) -> std::vector< mvalue_t< int > >::size_type"""
        return _oalib.vector_mvalue_t_int_capacity(self)

    __swig_destroy__ = _oalib.delete_vector_mvalue_t_int
    __del__ = lambda self: None
vector_mvalue_t_int_swigregister = _oalib.vector_mvalue_t_int_swigregister
vector_mvalue_t_int_swigregister(vector_mvalue_t_int)

class vector_mvalue_t_long(object):
    """Proxy of C++ std::vector<(mvalue_t<(long)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vector_mvalue_t_long self) -> SwigPyIterator"""
        return _oalib.vector_mvalue_t_long_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vector_mvalue_t_long self) -> bool"""
        return _oalib.vector_mvalue_t_long___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_mvalue_t_long self) -> bool"""
        return _oalib.vector_mvalue_t_long___bool__(self)


    def __len__(self):
        """__len__(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::size_type"""
        return _oalib.vector_mvalue_t_long___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i, std::vector< mvalue_t< long > >::difference_type j) -> vector_mvalue_t_long"""
        return _oalib.vector_mvalue_t_long___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i, std::vector< mvalue_t< long > >::difference_type j)
        __setslice__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i, std::vector< mvalue_t< long > >::difference_type j, vector_mvalue_t_long v)
        """
        return _oalib.vector_mvalue_t_long___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i, std::vector< mvalue_t< long > >::difference_type j)"""
        return _oalib.vector_mvalue_t_long___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i)
        __delitem__(vector_mvalue_t_long self, PySliceObject * slice)
        """
        return _oalib.vector_mvalue_t_long___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_mvalue_t_long self, PySliceObject * slice) -> vector_mvalue_t_long
        __getitem__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i) -> mvalue_t_long
        """
        return _oalib.vector_mvalue_t_long___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_mvalue_t_long self, PySliceObject * slice, vector_mvalue_t_long v)
        __setitem__(vector_mvalue_t_long self, PySliceObject * slice)
        __setitem__(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::difference_type i, mvalue_t_long x)
        """
        return _oalib.vector_mvalue_t_long___setitem__(self, *args)


    def pop(self):
        """pop(vector_mvalue_t_long self) -> mvalue_t_long"""
        return _oalib.vector_mvalue_t_long_pop(self)


    def append(self, x):
        """append(vector_mvalue_t_long self, mvalue_t_long x)"""
        return _oalib.vector_mvalue_t_long_append(self, x)


    def empty(self):
        """empty(vector_mvalue_t_long self) -> bool"""
        return _oalib.vector_mvalue_t_long_empty(self)


    def size(self):
        """size(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::size_type"""
        return _oalib.vector_mvalue_t_long_size(self)


    def swap(self, v):
        """swap(vector_mvalue_t_long self, vector_mvalue_t_long v)"""
        return _oalib.vector_mvalue_t_long_swap(self, v)


    def begin(self):
        """begin(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::iterator"""
        return _oalib.vector_mvalue_t_long_begin(self)


    def end(self):
        """end(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::iterator"""
        return _oalib.vector_mvalue_t_long_end(self)


    def rbegin(self):
        """rbegin(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_long_rbegin(self)


    def rend(self):
        """rend(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::reverse_iterator"""
        return _oalib.vector_mvalue_t_long_rend(self)


    def clear(self):
        """clear(vector_mvalue_t_long self)"""
        return _oalib.vector_mvalue_t_long_clear(self)


    def get_allocator(self):
        """get_allocator(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::allocator_type"""
        return _oalib.vector_mvalue_t_long_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_mvalue_t_long self)"""
        return _oalib.vector_mvalue_t_long_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::iterator pos) -> std::vector< mvalue_t< long > >::iterator
        erase(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::iterator first, std::vector< mvalue_t< long > >::iterator last) -> std::vector< mvalue_t< long > >::iterator
        """
        return _oalib.vector_mvalue_t_long_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(mvalue_t<(long)>)> self) -> vector_mvalue_t_long
        __init__(std::vector<(mvalue_t<(long)>)> self, vector_mvalue_t_long arg2) -> vector_mvalue_t_long
        __init__(std::vector<(mvalue_t<(long)>)> self, std::vector< mvalue_t< long > >::size_type size) -> vector_mvalue_t_long
        __init__(std::vector<(mvalue_t<(long)>)> self, std::vector< mvalue_t< long > >::size_type size, mvalue_t_long value) -> vector_mvalue_t_long
        """
        this = _oalib.new_vector_mvalue_t_long(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_mvalue_t_long self, mvalue_t_long x)"""
        return _oalib.vector_mvalue_t_long_push_back(self, x)


    def front(self):
        """front(vector_mvalue_t_long self) -> mvalue_t_long"""
        return _oalib.vector_mvalue_t_long_front(self)


    def back(self):
        """back(vector_mvalue_t_long self) -> mvalue_t_long"""
        return _oalib.vector_mvalue_t_long_back(self)


    def assign(self, n, x):
        """assign(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::size_type n, mvalue_t_long x)"""
        return _oalib.vector_mvalue_t_long_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::size_type new_size)
        resize(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::size_type new_size, mvalue_t_long x)
        """
        return _oalib.vector_mvalue_t_long_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::iterator pos, mvalue_t_long x) -> std::vector< mvalue_t< long > >::iterator
        insert(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::iterator pos, std::vector< mvalue_t< long > >::size_type n, mvalue_t_long x)
        """
        return _oalib.vector_mvalue_t_long_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_mvalue_t_long self, std::vector< mvalue_t< long > >::size_type n)"""
        return _oalib.vector_mvalue_t_long_reserve(self, n)


    def capacity(self):
        """capacity(vector_mvalue_t_long self) -> std::vector< mvalue_t< long > >::size_type"""
        return _oalib.vector_mvalue_t_long_capacity(self)

    __swig_destroy__ = _oalib.delete_vector_mvalue_t_long
    __del__ = lambda self: None
vector_mvalue_t_long_swigregister = _oalib.vector_mvalue_t_long_swigregister
vector_mvalue_t_long_swigregister(vector_mvalue_t_long)

class DequeParetoElementLong(object):
    """Proxy of C++ std::deque<(pareto_element<(mvalue_t<(long)>,long)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DequeParetoElementLong self) -> SwigPyIterator"""
        return _oalib.DequeParetoElementLong_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(DequeParetoElementLong self) -> bool"""
        return _oalib.DequeParetoElementLong___nonzero__(self)


    def __bool__(self):
        """__bool__(DequeParetoElementLong self) -> bool"""
        return _oalib.DequeParetoElementLong___bool__(self)


    def __len__(self):
        """__len__(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::size_type"""
        return _oalib.DequeParetoElementLong___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type j) -> DequeParetoElementLong"""
        return _oalib.DequeParetoElementLong___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type j)
        __setslice__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type j, DequeParetoElementLong v)
        """
        return _oalib.DequeParetoElementLong___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type j)"""
        return _oalib.DequeParetoElementLong___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i)
        __delitem__(DequeParetoElementLong self, PySliceObject * slice)
        """
        return _oalib.DequeParetoElementLong___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(DequeParetoElementLong self, PySliceObject * slice) -> DequeParetoElementLong
        __getitem__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i) -> ParetoElementLong
        """
        return _oalib.DequeParetoElementLong___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(DequeParetoElementLong self, PySliceObject * slice, DequeParetoElementLong v)
        __setitem__(DequeParetoElementLong self, PySliceObject * slice)
        __setitem__(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::difference_type i, ParetoElementLong x)
        """
        return _oalib.DequeParetoElementLong___setitem__(self, *args)


    def pop(self):
        """pop(DequeParetoElementLong self) -> ParetoElementLong"""
        return _oalib.DequeParetoElementLong_pop(self)


    def append(self, x):
        """append(DequeParetoElementLong self, ParetoElementLong x)"""
        return _oalib.DequeParetoElementLong_append(self, x)


    def empty(self):
        """empty(DequeParetoElementLong self) -> bool"""
        return _oalib.DequeParetoElementLong_empty(self)


    def size(self):
        """size(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::size_type"""
        return _oalib.DequeParetoElementLong_size(self)


    def swap(self, v):
        """swap(DequeParetoElementLong self, DequeParetoElementLong v)"""
        return _oalib.DequeParetoElementLong_swap(self, v)


    def begin(self):
        """begin(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::iterator"""
        return _oalib.DequeParetoElementLong_begin(self)


    def end(self):
        """end(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::iterator"""
        return _oalib.DequeParetoElementLong_end(self)


    def rbegin(self):
        """rbegin(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::reverse_iterator"""
        return _oalib.DequeParetoElementLong_rbegin(self)


    def rend(self):
        """rend(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::reverse_iterator"""
        return _oalib.DequeParetoElementLong_rend(self)


    def clear(self):
        """clear(DequeParetoElementLong self)"""
        return _oalib.DequeParetoElementLong_clear(self)


    def get_allocator(self):
        """get_allocator(DequeParetoElementLong self) -> std::deque< pareto_element< mvalue_t< long >,long > >::allocator_type"""
        return _oalib.DequeParetoElementLong_get_allocator(self)


    def pop_back(self):
        """pop_back(DequeParetoElementLong self)"""
        return _oalib.DequeParetoElementLong_pop_back(self)


    def erase(self, *args):
        """
        erase(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::iterator pos) -> std::deque< pareto_element< mvalue_t< long >,long > >::iterator
        erase(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::iterator first, std::deque< pareto_element< mvalue_t< long >,long > >::iterator last) -> std::deque< pareto_element< mvalue_t< long >,long > >::iterator
        """
        return _oalib.DequeParetoElementLong_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::deque<(pareto_element<(mvalue_t<(long)>,long)>)> self) -> DequeParetoElementLong
        __init__(std::deque<(pareto_element<(mvalue_t<(long)>,long)>)> self, DequeParetoElementLong arg2) -> DequeParetoElementLong
        __init__(std::deque<(pareto_element<(mvalue_t<(long)>,long)>)> self, std::deque< pareto_element< mvalue_t< long >,long > >::size_type size) -> DequeParetoElementLong
        __init__(std::deque<(pareto_element<(mvalue_t<(long)>,long)>)> self, std::deque< pareto_element< mvalue_t< long >,long > >::size_type size, ParetoElementLong value) -> DequeParetoElementLong
        """
        this = _oalib.new_DequeParetoElementLong(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(DequeParetoElementLong self, ParetoElementLong x)"""
        return _oalib.DequeParetoElementLong_push_back(self, x)


    def front(self):
        """front(DequeParetoElementLong self) -> ParetoElementLong"""
        return _oalib.DequeParetoElementLong_front(self)


    def back(self):
        """back(DequeParetoElementLong self) -> ParetoElementLong"""
        return _oalib.DequeParetoElementLong_back(self)


    def assign(self, n, x):
        """assign(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::size_type n, ParetoElementLong x)"""
        return _oalib.DequeParetoElementLong_assign(self, n, x)


    def resize(self, *args):
        """
        resize(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::size_type new_size)
        resize(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::size_type new_size, ParetoElementLong x)
        """
        return _oalib.DequeParetoElementLong_resize(self, *args)


    def insert(self, *args):
        """
        insert(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::iterator pos, ParetoElementLong x) -> std::deque< pareto_element< mvalue_t< long >,long > >::iterator
        insert(DequeParetoElementLong self, std::deque< pareto_element< mvalue_t< long >,long > >::iterator pos, std::deque< pareto_element< mvalue_t< long >,long > >::size_type n, ParetoElementLong x)
        """
        return _oalib.DequeParetoElementLong_insert(self, *args)


    def pop_front(self):
        """pop_front(DequeParetoElementLong self)"""
        return _oalib.DequeParetoElementLong_pop_front(self)


    def push_front(self, x):
        """push_front(DequeParetoElementLong self, ParetoElementLong x)"""
        return _oalib.DequeParetoElementLong_push_front(self, x)

    __swig_destroy__ = _oalib.delete_DequeParetoElementLong
    __del__ = lambda self: None
DequeParetoElementLong_swigregister = _oalib.DequeParetoElementLong_swigregister
DequeParetoElementLong_swigregister(DequeParetoElementLong)


# for legacy reasons and for name consistency
GWLPvalueVector = vector_mvalue_t_double
mvalueVector = vector_mvalue_t_long
#%template(mvalueVector) std::vector<mvalue_t<long> >;

class cpermVector(object):
    """Proxy of C++ std::vector<(cperm)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(cpermVector self) -> SwigPyIterator"""
        return _oalib.cpermVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(cpermVector self) -> bool"""
        return _oalib.cpermVector___nonzero__(self)


    def __bool__(self):
        """__bool__(cpermVector self) -> bool"""
        return _oalib.cpermVector___bool__(self)


    def __len__(self):
        """__len__(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type"""
        return _oalib.cpermVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type j) -> cpermVector"""
        return _oalib.cpermVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type j)
        __setslice__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type j, cpermVector v)
        """
        return _oalib.cpermVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type j)"""
        return _oalib.cpermVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i)
        __delitem__(cpermVector self, PySliceObject * slice)
        """
        return _oalib.cpermVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(cpermVector self, PySliceObject * slice) -> cpermVector
        __getitem__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i) -> charVector
        """
        return _oalib.cpermVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(cpermVector self, PySliceObject * slice, cpermVector v)
        __setitem__(cpermVector self, PySliceObject * slice)
        __setitem__(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::difference_type i, charVector x)
        """
        return _oalib.cpermVector___setitem__(self, *args)


    def pop(self):
        """pop(cpermVector self) -> charVector"""
        return _oalib.cpermVector_pop(self)


    def append(self, x):
        """append(cpermVector self, charVector x)"""
        return _oalib.cpermVector_append(self, x)


    def empty(self):
        """empty(cpermVector self) -> bool"""
        return _oalib.cpermVector_empty(self)


    def size(self):
        """size(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type"""
        return _oalib.cpermVector_size(self)


    def swap(self, v):
        """swap(cpermVector self, cpermVector v)"""
        return _oalib.cpermVector_swap(self, v)


    def begin(self):
        """begin(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator"""
        return _oalib.cpermVector_begin(self)


    def end(self):
        """end(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator"""
        return _oalib.cpermVector_end(self)


    def rbegin(self):
        """rbegin(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::reverse_iterator"""
        return _oalib.cpermVector_rbegin(self)


    def rend(self):
        """rend(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::reverse_iterator"""
        return _oalib.cpermVector_rend(self)


    def clear(self):
        """clear(cpermVector self)"""
        return _oalib.cpermVector_clear(self)


    def get_allocator(self):
        """get_allocator(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::allocator_type"""
        return _oalib.cpermVector_get_allocator(self)


    def pop_back(self):
        """pop_back(cpermVector self)"""
        return _oalib.cpermVector_pop_back(self)


    def erase(self, *args):
        """
        erase(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator pos) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator
        erase(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator first, std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator last) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator
        """
        return _oalib.cpermVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(cperm)> self) -> cpermVector
        __init__(std::vector<(cperm)> self, cpermVector arg2) -> cpermVector
        __init__(std::vector<(cperm)> self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type size) -> cpermVector
        __init__(std::vector<(cperm)> self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type size, charVector value) -> cpermVector
        """
        this = _oalib.new_cpermVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(cpermVector self, charVector x)"""
        return _oalib.cpermVector_push_back(self, x)


    def front(self):
        """front(cpermVector self) -> charVector"""
        return _oalib.cpermVector_front(self)


    def back(self):
        """back(cpermVector self) -> charVector"""
        return _oalib.cpermVector_back(self)


    def assign(self, n, x):
        """assign(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type n, charVector x)"""
        return _oalib.cpermVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type new_size)
        resize(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type new_size, charVector x)
        """
        return _oalib.cpermVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator pos, charVector x) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator
        insert(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::iterator pos, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type n, charVector x)
        """
        return _oalib.cpermVector_insert(self, *args)


    def reserve(self, n):
        """reserve(cpermVector self, std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type n)"""
        return _oalib.cpermVector_reserve(self, n)


    def capacity(self):
        """capacity(cpermVector self) -> std::vector< std::vector< signed char,std::allocator< signed char > > >::size_type"""
        return _oalib.cpermVector_capacity(self)

    __swig_destroy__ = _oalib.delete_cpermVector
    __del__ = lambda self: None
cpermVector_swigregister = _oalib.cpermVector_swigregister
cpermVector_swigregister(cpermVector)


def calculateArrayParetoJ5(al, verbose):
    """
    calculateArrayParetoJ5(array_link al, int verbose) -> Pareto< mvalue_t< long >,array_link >::pValue

    Pareto< mvalue_t <
    long >, IndexType >::pValue calculateArrayParetoJ5(const array_link
    &al, int verbose) 
    """
    return _oalib.calculateArrayParetoJ5(al, verbose)

def calculateArrayParetoJ5int(al, verbose):
    """
    calculateArrayParetoJ5int(array_link al, int verbose) -> Pareto< mvalue_t< long >,int >::pValue

    Pareto< mvalue_t <
    long >, IndexType >::pValue calculateArrayParetoJ5(const array_link
    &al, int verbose) 
    """
    return _oalib.calculateArrayParetoJ5int(al, verbose)

def calculateArrayParetoJ5long(al, verbose):
    """
    calculateArrayParetoJ5long(array_link al, int verbose) -> vector_mvalue_t_long

    Pareto< mvalue_t <
    long >, IndexType >::pValue calculateArrayParetoJ5(const array_link
    &al, int verbose) 
    """
    return _oalib.calculateArrayParetoJ5long(al, verbose)
class vector_vector_double(object):
    """Proxy of C++ std::vector<(std::vector<(double)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vector_vector_double self) -> SwigPyIterator"""
        return _oalib.vector_vector_double_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vector_vector_double self) -> bool"""
        return _oalib.vector_vector_double___nonzero__(self)


    def __bool__(self):
        """__bool__(vector_vector_double self) -> bool"""
        return _oalib.vector_vector_double___bool__(self)


    def __len__(self):
        """__len__(vector_vector_double self) -> std::vector< std::vector< double > >::size_type"""
        return _oalib.vector_vector_double___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j) -> vector_vector_double"""
        return _oalib.vector_vector_double___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)
        __setslice__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j, vector_vector_double v)
        """
        return _oalib.vector_vector_double___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i, std::vector< std::vector< double > >::difference_type j)"""
        return _oalib.vector_vector_double___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i)
        __delitem__(vector_vector_double self, PySliceObject * slice)
        """
        return _oalib.vector_vector_double___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(vector_vector_double self, PySliceObject * slice) -> vector_vector_double
        __getitem__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i) -> doubleVector
        """
        return _oalib.vector_vector_double___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vector_vector_double self, PySliceObject * slice, vector_vector_double v)
        __setitem__(vector_vector_double self, PySliceObject * slice)
        __setitem__(vector_vector_double self, std::vector< std::vector< double > >::difference_type i, doubleVector x)
        """
        return _oalib.vector_vector_double___setitem__(self, *args)


    def pop(self):
        """pop(vector_vector_double self) -> doubleVector"""
        return _oalib.vector_vector_double_pop(self)


    def append(self, x):
        """append(vector_vector_double self, doubleVector x)"""
        return _oalib.vector_vector_double_append(self, x)


    def empty(self):
        """empty(vector_vector_double self) -> bool"""
        return _oalib.vector_vector_double_empty(self)


    def size(self):
        """size(vector_vector_double self) -> std::vector< std::vector< double > >::size_type"""
        return _oalib.vector_vector_double_size(self)


    def swap(self, v):
        """swap(vector_vector_double self, vector_vector_double v)"""
        return _oalib.vector_vector_double_swap(self, v)


    def begin(self):
        """begin(vector_vector_double self) -> std::vector< std::vector< double > >::iterator"""
        return _oalib.vector_vector_double_begin(self)


    def end(self):
        """end(vector_vector_double self) -> std::vector< std::vector< double > >::iterator"""
        return _oalib.vector_vector_double_end(self)


    def rbegin(self):
        """rbegin(vector_vector_double self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _oalib.vector_vector_double_rbegin(self)


    def rend(self):
        """rend(vector_vector_double self) -> std::vector< std::vector< double > >::reverse_iterator"""
        return _oalib.vector_vector_double_rend(self)


    def clear(self):
        """clear(vector_vector_double self)"""
        return _oalib.vector_vector_double_clear(self)


    def get_allocator(self):
        """get_allocator(vector_vector_double self) -> std::vector< std::vector< double > >::allocator_type"""
        return _oalib.vector_vector_double_get_allocator(self)


    def pop_back(self):
        """pop_back(vector_vector_double self)"""
        return _oalib.vector_vector_double_pop_back(self)


    def erase(self, *args):
        """
        erase(vector_vector_double self, std::vector< std::vector< double > >::iterator pos) -> std::vector< std::vector< double > >::iterator
        erase(vector_vector_double self, std::vector< std::vector< double > >::iterator first, std::vector< std::vector< double > >::iterator last) -> std::vector< std::vector< double > >::iterator
        """
        return _oalib.vector_vector_double_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(double)>)> self) -> vector_vector_double
        __init__(std::vector<(std::vector<(double)>)> self, vector_vector_double arg2) -> vector_vector_double
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size) -> vector_vector_double
        __init__(std::vector<(std::vector<(double)>)> self, std::vector< std::vector< double > >::size_type size, doubleVector value) -> vector_vector_double
        """
        this = _oalib.new_vector_vector_double(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        """push_back(vector_vector_double self, doubleVector x)"""
        return _oalib.vector_vector_double_push_back(self, x)


    def front(self):
        """front(vector_vector_double self) -> doubleVector"""
        return _oalib.vector_vector_double_front(self)


    def back(self):
        """back(vector_vector_double self) -> doubleVector"""
        return _oalib.vector_vector_double_back(self)


    def assign(self, n, x):
        """assign(vector_vector_double self, std::vector< std::vector< double > >::size_type n, doubleVector x)"""
        return _oalib.vector_vector_double_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vector_vector_double self, std::vector< std::vector< double > >::size_type new_size)
        resize(vector_vector_double self, std::vector< std::vector< double > >::size_type new_size, doubleVector x)
        """
        return _oalib.vector_vector_double_resize(self, *args)


    def insert(self, *args):
        """
        insert(vector_vector_double self, std::vector< std::vector< double > >::iterator pos, doubleVector x) -> std::vector< std::vector< double > >::iterator
        insert(vector_vector_double self, std::vector< std::vector< double > >::iterator pos, std::vector< std::vector< double > >::size_type n, doubleVector x)
        """
        return _oalib.vector_vector_double_insert(self, *args)


    def reserve(self, n):
        """reserve(vector_vector_double self, std::vector< std::vector< double > >::size_type n)"""
        return _oalib.vector_vector_double_reserve(self, n)


    def capacity(self):
        """capacity(vector_vector_double self) -> std::vector< std::vector< double > >::size_type"""
        return _oalib.vector_vector_double_capacity(self)

    __swig_destroy__ = _oalib.delete_vector_vector_double
    __del__ = lambda self: None
vector_vector_double_swigregister = _oalib.vector_vector_double_swigregister
vector_vector_double_swigregister(vector_vector_double)


__doc__ = """
Python Orthogonal Array Interface 2
"""


def iarray_get(a, index):
    """iarray_get(int * a, int index) -> double"""
    return _oalib.iarray_get(a, index)


