python-dolfin 1.3.0+dfsg-2 / usr / lib / python2.7 / dist-packages / dolfin / cpp / common.py

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





from sys import version_info
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _common.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
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('_common', [dirname(__file__)])
        except ImportError:
            import _common
            return _common
        if fp is not None:
            try:
                _mod = imp.load_module('_common', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _common = swig_import_helper()
    del swig_import_helper
else:
    import _common
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):
        self.__dict__[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(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: 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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


SHARED_PTR_DISOWN = _common.SHARED_PTR_DISOWN
import ufc

def _attach_base_to_numpy_array(*args):
  return _common._attach_base_to_numpy_array(*args)
_attach_base_to_numpy_array = _common._attach_base_to_numpy_array

def dolfin_swigversion(*args):
  return _common.dolfin_swigversion(*args)
dolfin_swigversion = _common.dolfin_swigversion
tmp = hex(dolfin_swigversion())
__swigversion__ = "%d.%d.%d"%(tuple(map(int, [tmp[-5], tmp[-3], tmp[-2:]])))
del tmp, dolfin_swigversion


def has_petsc4py(*args):
  return _common.has_petsc4py(*args)
has_petsc4py = _common.has_petsc4py

def init(*args):
  """
    Initialize DOLFIN (and PETSc) with command-line arguments. This
    should not be needed in most cases since the initialization is
    otherwise handled automatically.

    """
  return _common.init(*args)

def dolfin_version(*args):
  """
    Return DOLFIN version string

    """
  return _common.dolfin_version(*args)

def git_commit_hash(*args):
  """
    Return git changeset hash (returns "unknown" if changeset is
    not known)

    """
  return _common.git_commit_hash(*args)

def has_openmp(*args):
  """
    Return true if DOLFIN is compiled with OpenMP

    """
  return _common.has_openmp(*args)

def has_mpi(*args):
  """
    Return true if DOLFIN is compiled with MPI

    """
  return _common.has_mpi(*args)

def has_petsc(*args):
  """
    Return true if DOLFIN is compiled with PETSc

    """
  return _common.has_petsc(*args)

def has_slepc(*args):
  """
    Return true if DOLFIN is compiled with SLEPc

    """
  return _common.has_slepc(*args)

def has_tao(*args):
  """
    Return true if DOLFIN is compiled with TAO

    """
  return _common.has_tao(*args)

def has_trilinos(*args):
  """
    Return true if DOLFIN is compiled with Trilinos

    """
  return _common.has_trilinos(*args)

def has_scotch(*args):
  """
    Return true if DOLFIN is compiled with Scotch

    """
  return _common.has_scotch(*args)

def has_cgal(*args):
  """
    Return true if DOLFIN is compiled with CGAL

    """
  return _common.has_cgal(*args)

def has_umfpack(*args):
  """
    Return true if DOLFIN is compiled with Umfpack

    """
  return _common.has_umfpack(*args)

def has_cholmod(*args):
  """
    Return true if DOLFIN is compiled with Cholmod

    """
  return _common.has_cholmod(*args)

def has_parmetis(*args):
  """
    Return true if DOLFIN is compiled with ParMETIS

    """
  return _common.has_parmetis(*args)

def has_zlib(*args):
  """
    Return true if DOLFIN is compiled with ZLIB

    """
  return _common.has_zlib(*args)

def has_hdf5(*args):
  """
    Return true if DOLFIN is compiled with HDF5

    """
  return _common.has_hdf5(*args)

def has_exodus(*args):
  """
    Return true if DOLFIN is compiled with Exodus

    """
  return _common.has_exodus(*args)
DOLFIN_EPS = _common.DOLFIN_EPS
DOLFIN_EPS_LARGE = _common.DOLFIN_EPS_LARGE
DOLFIN_SQRT_EPS = _common.DOLFIN_SQRT_EPS
DOLFIN_PI = _common.DOLFIN_PI
DOLFIN_LINELENGTH = _common.DOLFIN_LINELENGTH
DOLFIN_TERM_WIDTH = _common.DOLFIN_TERM_WIDTH

def tic(*args):
  """
    Timing functions measure CPU time as determined by clock(),
    the precision of which seems to be 0.01 seconds.
    Start timing (should not be used internally in DOLFIN!)

    """
  return _common.tic(*args)

def toc(*args):
  """
    Return elapsed CPU time (should not be used internally in DOLFIN!)

    """
  return _common.toc(*args)

def time(*args):
  """
    Return current CPU time used by process

    """
  return _common.time(*args)

def timings(*args):
  """
    Return a summary of timings and tasks in a Table, optionally clearing
    stored timings

    """
  return _common.timings(*args)

def list_timings(*args):
  """
    List a summary of timings and tasks, optionally clearing stored timings

    """
  return _common.list_timings(*args)

def summary(*args):
  """
    This function is deprecated, use list_timings

    """
  return _common.summary(*args)

def timing(*args):
  """
    Return timing (average) for given task, optionally clearing timing
    for task

    """
  return _common.timing(*args)
class IndexSet(object):
    """
    This class provides an efficient data structure for index sets.
    The cost of checking whether a given index is in the set is O(1)
    and very very fast (optimal) at the cost of extra storage.

    """
    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): 
        """
        Create index set of given size

        """
        _common.IndexSet_swiginit(self,_common.new_IndexSet(*args))
    __swig_destroy__ = _common.delete_IndexSet
    def empty(self, *args):
        """
        Return true if set is empty

        """
        return _common.IndexSet_empty(self, *args)

    def size(self, *args):
        """
        Return size of set

        """
        return _common.IndexSet_size(self, *args)

    def has_index(self, *args):
        """
        Check whether index is in set

        """
        return _common.IndexSet_has_index(self, *args)

    def find(self, *args):
        """
        Return position (if any) for given index

        """
        return _common.IndexSet_find(self, *args)

    def insert(self, *args):
        """
        Insert index into set

        """
        return _common.IndexSet_insert(self, *args)

    def fill(self, *args):
        """
        Fill index set with indices 0, 1, 2, ..., size - 1

        """
        return _common.IndexSet_fill(self, *args)

    def clear(self, *args):
        """
        Clear set

        """
        return _common.IndexSet_clear(self, *args)

IndexSet.empty = new_instancemethod(_common.IndexSet_empty,None,IndexSet)
IndexSet.size = new_instancemethod(_common.IndexSet_size,None,IndexSet)
IndexSet.has_index = new_instancemethod(_common.IndexSet_has_index,None,IndexSet)
IndexSet.find = new_instancemethod(_common.IndexSet_find,None,IndexSet)
IndexSet.insert = new_instancemethod(_common.IndexSet_insert,None,IndexSet)
IndexSet.fill = new_instancemethod(_common.IndexSet_fill,None,IndexSet)
IndexSet.clear = new_instancemethod(_common.IndexSet_clear,None,IndexSet)
IndexSet_swigregister = _common.IndexSet_swigregister
IndexSet_swigregister(IndexSet)

class Timer(object):
    """
    A timer can be used for timing tasks. The basic usage is

      Timer timer("Assembling over cells");

    The timer is started at construction and timing ends
    when the timer is destroyed (goes out of scope). It is
    also possible to start and stop a timer explicitly by

      timer.start();
      timer.stop();

    Timings are stored globally and a summary may be printed
    by calling

      list_timings();

    """
    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): 
        """
        Create timer

        """
        _common.Timer_swiginit(self,_common.new_Timer(*args))
    __swig_destroy__ = _common.delete_Timer
    def start(self, *args):
        """
        Start timer

        """
        return _common.Timer_start(self, *args)

    def stop(self, *args):
        """
        Stop timer

        """
        return _common.Timer_stop(self, *args)

    def value(self, *args):
        """
        Return value of timer (or time at start if not stopped)

        """
        return _common.Timer_value(self, *args)

Timer.start = new_instancemethod(_common.Timer_start,None,Timer)
Timer.stop = new_instancemethod(_common.Timer_stop,None,Timer)
Timer.value = new_instancemethod(_common.Timer_value,None,Timer)
Timer_swigregister = _common.Timer_swigregister
Timer_swigregister(Timer)

class Variable(object):
    """
    Common base class for DOLFIN variables.

    """
    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): 
        """
        **Overloaded versions**

        * Variable\ ()

          Create unnamed variable

        * Variable\ (name, label)

          Create variable with given name and label

        * Variable\ (variable)

          Copy constructor

        """
        _common.Variable_swiginit(self,_common.new_Variable(*args))
    __swig_destroy__ = _common.delete_Variable
    def rename(self, *args):
        """
        Rename variable

        """
        return _common.Variable_rename(self, *args)

    def name(self, *args):
        """
        Return name

        """
        return _common.Variable_name(self, *args)

    def label(self, *args):
        """
        Return label (description)

        """
        return _common.Variable_label(self, *args)

    def id(self, *args):
        """
        Get unique identifier.

        *Returns*
            _std::size_t_
                The unique integer identifier associated with the object.

        """
        return _common.Variable_id(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _common.Variable_str(self, *args)

    parameters = _swig_property(_common.Variable_parameters_get, _common.Variable_parameters_set)
    def __str__(self, *args):
        """Missing docstring"""
        return _common.Variable___str__(self, *args)

Variable.rename = new_instancemethod(_common.Variable_rename,None,Variable)
Variable.name = new_instancemethod(_common.Variable_name,None,Variable)
Variable.label = new_instancemethod(_common.Variable_label,None,Variable)
Variable.id = new_instancemethod(_common.Variable_id,None,Variable)
Variable.str = new_instancemethod(_common.Variable_str,None,Variable)
Variable.__str__ = new_instancemethod(_common.Variable___str__,None,Variable)
Variable_swigregister = _common.Variable_swigregister
Variable_swigregister(Variable)

MPICH_IGNORE_CXX_SEEK = _common.MPICH_IGNORE_CXX_SEEK
class MPICommunicator(object):
    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): 
        """
        Create communicator (copy of MPI_COMM_WORLD)

        """
        _common.MPICommunicator_swiginit(self,_common.new_MPICommunicator(*args))
    __swig_destroy__ = _common.delete_MPICommunicator
    def __ref__(self, *args):
        """
        Dereference operator

        """
        return _common.MPICommunicator___ref__(self, *args)

MPICommunicator.__ref__ = new_instancemethod(_common.MPICommunicator___ref__,None,MPICommunicator)
MPICommunicator_swigregister = _common.MPICommunicator_swigregister
MPICommunicator_swigregister(MPICommunicator)

class MPIInfo(object):
    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): 
        _common.MPIInfo_swiginit(self,_common.new_MPIInfo(*args))
    __swig_destroy__ = _common.delete_MPIInfo
MPIInfo.__ref__ = new_instancemethod(_common.MPIInfo___ref__,None,MPIInfo)
MPIInfo_swigregister = _common.MPIInfo_swigregister
MPIInfo_swigregister(MPIInfo)

class MPINonblocking(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_MPINonblocking
    def wait_all(self, *args):
        """
        Wait for all requests to finish

        """
        return _common.MPINonblocking_wait_all(self, *args)

    def __init__(self, *args): 
        _common.MPINonblocking_swiginit(self,_common.new_MPINonblocking(*args))
MPINonblocking.wait_all = new_instancemethod(_common.MPINonblocking_wait_all,None,MPINonblocking)
MPINonblocking_swigregister = _common.MPINonblocking_swigregister
MPINonblocking_swigregister(MPINonblocking)

class MPI(object):
    """
    This class provides utility functions for easy communcation
    with MPI.

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def process_number(*args):
        """
        Return proccess number

        """
        return _common.MPI_process_number(*args)

    process_number = staticmethod(process_number)
    def num_processes(*args):
        """
        Return number of processes

        """
        return _common.MPI_num_processes(*args)

    num_processes = staticmethod(num_processes)
    def is_broadcaster(*args):
        """
        Determine whether we should broadcast (based on current parallel
        policy)

        """
        return _common.MPI_is_broadcaster(*args)

    is_broadcaster = staticmethod(is_broadcaster)
    def is_receiver(*args):
        """
        Determine whether we should receive (based on current parallel
        policy)

        """
        return _common.MPI_is_receiver(*args)

    is_receiver = staticmethod(is_receiver)
    def barrier(*args):
        """
        Set a barrier (synchronization point)

        """
        return _common.MPI_barrier(*args)

    barrier = staticmethod(barrier)
    def global_offset(*args):
        """
        Find global offset (index) (wrapper for MPI_(Ex)Scan with MPI_SUM as
        reduction op)

        """
        return _common.MPI_global_offset(*args)

    global_offset = staticmethod(global_offset)
    def local_range(*args):
        """
        **Overloaded versions**

        * local_range\ (N)

          Return local range for local process, splitting [0, N - 1] into
          num_processes() portions of almost equal size

        * local_range\ (process, N)

          Return local range for given process, splitting [0, N - 1] into
          num_processes() portions of almost equal size

        * local_range\ (process, N, num_processes)

          Return local range for given process, splitting [0, N - 1] into
          num_processes portions of almost equal size

        """
        return _common.MPI_local_range(*args)

    local_range = staticmethod(local_range)
    def index_owner(*args):
        """
        Return which process owns index (inverse of local_range)

        """
        return _common.MPI_index_owner(*args)

    index_owner = staticmethod(index_owner)
    def max(*args):
        """
        Return global max value

        """
        return _common.MPI_max(*args)

    max = staticmethod(max)
    def min(*args):
        """
        Return global min value

        """
        return _common.MPI_min(*args)

    min = staticmethod(min)
    def sum(*args):
        """
        Sum values and return sum

        """
        return _common.MPI_sum(*args)

    sum = staticmethod(sum)
    def __init__(self, *args): 
        _common.MPI_swiginit(self,_common.new_MPI(*args))
    __swig_destroy__ = _common.delete_MPI
MPI_swigregister = _common.MPI_swigregister
MPI_swigregister(MPI)

def MPI_process_number(*args):
  """
    Return proccess number

    """
  return _common.MPI_process_number(*args)

def MPI_num_processes(*args):
  """
    Return number of processes

    """
  return _common.MPI_num_processes(*args)

def MPI_is_broadcaster(*args):
  """
    Determine whether we should broadcast (based on current parallel
    policy)

    """
  return _common.MPI_is_broadcaster(*args)

def MPI_is_receiver(*args):
  """
    Determine whether we should receive (based on current parallel
    policy)

    """
  return _common.MPI_is_receiver(*args)

def MPI_barrier(*args):
  """
    Set a barrier (synchronization point)

    """
  return _common.MPI_barrier(*args)

def MPI_global_offset(*args):
  """
    Find global offset (index) (wrapper for MPI_(Ex)Scan with MPI_SUM as
    reduction op)

    """
  return _common.MPI_global_offset(*args)

def MPI_local_range(*args):
  """
    **Overloaded versions**

    * local_range\ (N)

      Return local range for local process, splitting [0, N - 1] into
      num_processes() portions of almost equal size

    * local_range\ (process, N)

      Return local range for given process, splitting [0, N - 1] into
      num_processes() portions of almost equal size

    * local_range\ (process, N, num_processes)

      Return local range for given process, splitting [0, N - 1] into
      num_processes portions of almost equal size

    """
  return _common.MPI_local_range(*args)

def MPI_index_owner(*args):
  """
    Return which process owns index (inverse of local_range)

    """
  return _common.MPI_index_owner(*args)

def MPI_max(*args):
  """
    Return global max value

    """
  return _common.MPI_max(*args)

def MPI_min(*args):
  """
    Return global min value

    """
  return _common.MPI_min(*args)

def MPI_sum(*args):
  """
    Sum values and return sum

    """
  return _common.MPI_sum(*args)

class SubSystemsManager(object):
    """
    This is a singleton class which manages the initialisation and
    finalisation of various sub systems, such as MPI and PETSc.

    """
    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")
    __repr__ = _swig_repr
    def init_mpi(*args):
        """
        **Overloaded versions**

        * init_mpi\ ()

          Initialise MPI

        * init_mpi\ (argc, argv[], required_thread_level)

          Initialise MPI with required level of thread support

        """
        return _common.SubSystemsManager_init_mpi(*args)

    init_mpi = staticmethod(init_mpi)
    def init_petsc(*args):
        """
        **Overloaded versions**

        * init_petsc\ ()

          Initialize PETSc without command-line arguments

        * init_petsc\ (argc, argv[])

          Initialize PETSc with command-line arguments. Note that PETSc
          command-line arguments may also be filtered and sent to PETSc
          by parameters.parse(argc, argv).

        """
        return _common.SubSystemsManager_init_petsc(*args)

    init_petsc = staticmethod(init_petsc)
    def finalize(*args):
        """
        Finalize subsytems. This will be called by the destructor, but in
        special cases it may be necessary to call finalize() explicitly.

        """
        return _common.SubSystemsManager_finalize(*args)

    finalize = staticmethod(finalize)
    def responsible_mpi(*args):
        """
        Return true if DOLFIN intialised MPI (and is therefore responsible
        for finalization)

        """
        return _common.SubSystemsManager_responsible_mpi(*args)

    responsible_mpi = staticmethod(responsible_mpi)
    def responsible_petsc(*args):
        """
        Return true if DOLFIN intialised PETSc (and is therefore
        responsible for finalization)

        """
        return _common.SubSystemsManager_responsible_petsc(*args)

    responsible_petsc = staticmethod(responsible_petsc)
    def mpi_initialized(*args):
        """
        Check if MPI has been initialised (returns true if MPI has been
        initialised, even if it is later finalised)

        """
        return _common.SubSystemsManager_mpi_initialized(*args)

    mpi_initialized = staticmethod(mpi_initialized)
    def mpi_finalized(*args):
        """
        Check if MPI has been finalized (returns true if MPI has been
        finalised)

        """
        return _common.SubSystemsManager_mpi_finalized(*args)

    mpi_finalized = staticmethod(mpi_finalized)
SubSystemsManager_swigregister = _common.SubSystemsManager_swigregister
SubSystemsManager_swigregister(SubSystemsManager)

def SubSystemsManager_init_mpi(*args):
  """
    **Overloaded versions**

    * init_mpi\ ()

      Initialise MPI

    * init_mpi\ (argc, argv[], required_thread_level)

      Initialise MPI with required level of thread support

    """
  return _common.SubSystemsManager_init_mpi(*args)

def SubSystemsManager_init_petsc(*args):
  """
    **Overloaded versions**

    * init_petsc\ ()

      Initialize PETSc without command-line arguments

    * init_petsc\ (argc, argv[])

      Initialize PETSc with command-line arguments. Note that PETSc
      command-line arguments may also be filtered and sent to PETSc
      by parameters.parse(argc, argv).

    """
  return _common.SubSystemsManager_init_petsc(*args)

def SubSystemsManager_finalize(*args):
  """
    Finalize subsytems. This will be called by the destructor, but in
    special cases it may be necessary to call finalize() explicitly.

    """
  return _common.SubSystemsManager_finalize(*args)

def SubSystemsManager_responsible_mpi(*args):
  """
    Return true if DOLFIN intialised MPI (and is therefore responsible
    for finalization)

    """
  return _common.SubSystemsManager_responsible_mpi(*args)

def SubSystemsManager_responsible_petsc(*args):
  """
    Return true if DOLFIN intialised PETSc (and is therefore
    responsible for finalization)

    """
  return _common.SubSystemsManager_responsible_petsc(*args)

def SubSystemsManager_mpi_initialized(*args):
  """
    Check if MPI has been initialised (returns true if MPI has been
    initialised, even if it is later finalised)

    """
  return _common.SubSystemsManager_mpi_initialized(*args)

def SubSystemsManager_mpi_finalized(*args):
  """
    Check if MPI has been finalized (returns true if MPI has been
    finalised)

    """
  return _common.SubSystemsManager_mpi_finalized(*args)

class DoubleArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A
    purpose of this class is to enable the simple and safe exchange
    of data between C++ and Python.

    """
    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): 
        """
        **Overloaded versions**

        * Array\ (N)

          Create array of size N. Array has ownership.

        * Array\ (N, x)

          Construct array from a pointer. Array does not take ownership.

        * Array\ (other)

          Disable copy construction, to avoid unanticipated sharing or
          copying of data. This means that an Array must always be passed as
          reference, or as a (possibly shared) pointer.

        """
        _common.DoubleArray_swiginit(self,_common.new_DoubleArray(*args))
    __swig_destroy__ = _common.delete_DoubleArray
    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _common.DoubleArray_str(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _common.DoubleArray_size(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _common.DoubleArray_data(self, *args)

    def array(self):
        """
        Return a NumPy array view of object
        """
        data = self._array()
        _attach_base_to_numpy_array(data, self)
        return data

    def __getitem__(self, index):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        return self._getitem(index)
        
    def __setitem__(self, index, value):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        self._setitem(index, value)

    def __len__(self):
        return self.size()
        
DoubleArray.str = new_instancemethod(_common.DoubleArray_str,None,DoubleArray)
DoubleArray.size = new_instancemethod(_common.DoubleArray_size,None,DoubleArray)
DoubleArray.data = new_instancemethod(_common.DoubleArray_data,None,DoubleArray)
DoubleArray._getitem = new_instancemethod(_common.DoubleArray__getitem,None,DoubleArray)
DoubleArray._setitem = new_instancemethod(_common.DoubleArray__setitem,None,DoubleArray)
DoubleArray._array = new_instancemethod(_common.DoubleArray__array,None,DoubleArray)
DoubleArray_swigregister = _common.DoubleArray_swigregister
DoubleArray_swigregister(DoubleArray)

class UIntArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A
    purpose of this class is to enable the simple and safe exchange
    of data between C++ and Python.

    """
    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): 
        """
        **Overloaded versions**

        * Array\ (N)

          Create array of size N. Array has ownership.

        * Array\ (N, x)

          Construct array from a pointer. Array does not take ownership.

        * Array\ (other)

          Disable copy construction, to avoid unanticipated sharing or
          copying of data. This means that an Array must always be passed as
          reference, or as a (possibly shared) pointer.

        """
        _common.UIntArray_swiginit(self,_common.new_UIntArray(*args))
    __swig_destroy__ = _common.delete_UIntArray
    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _common.UIntArray_str(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _common.UIntArray_size(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _common.UIntArray_data(self, *args)

    def array(self):
        """
        Return a NumPy array view of object
        """
        data = self._array()
        _attach_base_to_numpy_array(data, self)
        return data

    def __getitem__(self, index):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        return self._getitem(index)
        
    def __setitem__(self, index, value):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        self._setitem(index, value)

    def __len__(self):
        return self.size()
        
UIntArray.str = new_instancemethod(_common.UIntArray_str,None,UIntArray)
UIntArray.size = new_instancemethod(_common.UIntArray_size,None,UIntArray)
UIntArray.data = new_instancemethod(_common.UIntArray_data,None,UIntArray)
UIntArray._getitem = new_instancemethod(_common.UIntArray__getitem,None,UIntArray)
UIntArray._setitem = new_instancemethod(_common.UIntArray__setitem,None,UIntArray)
UIntArray._array = new_instancemethod(_common.UIntArray__array,None,UIntArray)
UIntArray_swigregister = _common.UIntArray_swigregister
UIntArray_swigregister(UIntArray)

class IntArray(object):
    """
    This class provides a simple wrapper for a pointer to an array. A
    purpose of this class is to enable the simple and safe exchange
    of data between C++ and Python.

    """
    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): 
        """
        **Overloaded versions**

        * Array\ (N)

          Create array of size N. Array has ownership.

        * Array\ (N, x)

          Construct array from a pointer. Array does not take ownership.

        * Array\ (other)

          Disable copy construction, to avoid unanticipated sharing or
          copying of data. This means that an Array must always be passed as
          reference, or as a (possibly shared) pointer.

        """
        _common.IntArray_swiginit(self,_common.new_IntArray(*args))
    __swig_destroy__ = _common.delete_IntArray
    def str(self, *args):
        """
        Return informal string representation (pretty-print).
        Note that the Array class is not a subclass of Variable (for
        efficiency) which means that one needs to call str() directly
        instead of using the info() function on Array objects.

        """
        return _common.IntArray_str(self, *args)

    def size(self, *args):
        """
        Return size of array

        """
        return _common.IntArray_size(self, *args)

    def data(self, *args):
        """
        **Overloaded versions**

        * data\ ()

          Return pointer to data (const version)

        * data\ ()

          Return pointer to data (non-const version)

        """
        return _common.IntArray_data(self, *args)

    def array(self):
        """
        Return a NumPy array view of object
        """
        data = self._array()
        _attach_base_to_numpy_array(data, self)
        return data

    def __getitem__(self, index):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        return self._getitem(index)
        
    def __setitem__(self, index, value):
        if not isinstance(index, int):
            raise TypeError("expected an int as index argument")
        while index < 0:
            index += self.size()
        if index >= self.size():
            raise IndexError("index out of range")
        self._setitem(index, value)

    def __len__(self):
        return self.size()
        
IntArray.str = new_instancemethod(_common.IntArray_str,None,IntArray)
IntArray.size = new_instancemethod(_common.IntArray_size,None,IntArray)
IntArray.data = new_instancemethod(_common.IntArray_data,None,IntArray)
IntArray._getitem = new_instancemethod(_common.IntArray__getitem,None,IntArray)
IntArray._setitem = new_instancemethod(_common.IntArray__setitem,None,IntArray)
IntArray._array = new_instancemethod(_common.IntArray__array,None,IntArray)
IntArray_swigregister = _common.IntArray_swigregister
IntArray_swigregister(IntArray)

class ParameterValue(object):
    """
    Base class for parameters.

    """
    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__ = _common.delete_ParameterValue
    def key(self, *args):
        """
        Return parameter key

        """
        return _common.ParameterValue_key(self, *args)

    def description(self, *args):
        """
        Return parameter description

        """
        return _common.ParameterValue_description(self, *args)

    def is_set(self, *args):
        """
        Return true if parameter is set, return false otherwise

        """
        return _common.ParameterValue_is_set(self, *args)

    def reset(self, *args):
        """
        Reset the parameter to empty, so that is_set() returns false.

        """
        return _common.ParameterValue_reset(self, *args)

    def access_count(self, *args):
        """
        Return access count (number of times parameter has been accessed)

        """
        return _common.ParameterValue_access_count(self, *args)

    def change_count(self, *args):
        """
        Return change count (number of times parameter has been changed)

        """
        return _common.ParameterValue_change_count(self, *args)

    def set_range(self, *args):
        """
        **Overloaded versions**

        * set_range\ (min_value, max_value)

          Set range for int-valued parameter

        * set_range\ (min_value, max_value)

          Set range for double-valued parameter

        * set_range\ (range)

          Set range for string-valued parameter

        """
        return _common.ParameterValue_set_range(self, *args)

    def _get_int_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _common.ParameterValue__get_int_range(self, *args)

    def _get_double_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _common.ParameterValue__get_double_range(self, *args)

    def _get_string_range(self, *args):
        """
        **Overloaded versions**

        * get_range\ (min_value, max_value)

          Get range for int-valued parameter

        * get_range\ (min_value, max_value)

          Get range for double-valued parameter

        * get_range\ (range)

          Get range for string-valued parameter

        """
        return _common.ParameterValue__get_string_range(self, *args)

    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment from int

        * operator=\ (value)

          Assignment from double

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from bool

        """
        return _common.ParameterValue__assign(self, *args)

    def _assign_bool(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment from int

        * operator=\ (value)

          Assignment from double

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from string

        * operator=\ (value)

          Assignment from bool

        """
        return _common.ParameterValue__assign_bool(self, *args)

    def __int__(self, *args):
        """
        Cast parameter to int

        """
        return _common.ParameterValue___int__(self, *args)

    def __float__(self, *args):
        """
        Cast parameter to double

        """
        return _common.ParameterValue___float__(self, *args)

    def __str__(self, *args):
        """
        Cast parameter to string

        """
        return _common.ParameterValue___str__(self, *args)

    def __nonzero__(self):
        return _common.ParameterValue___nonzero__(self)
    __bool__ = __nonzero__


    def type_str(self, *args):
        """
        Return value type string

        """
        return _common.ParameterValue_type_str(self, *args)

    def value_str(self, *args):
        """
        Return value string

        """
        return _common.ParameterValue_value_str(self, *args)

    def range_str(self, *args):
        """
        Return range string

        """
        return _common.ParameterValue_range_str(self, *args)

    def str(self, *args):
        """
        Return short string description

        """
        return _common.ParameterValue_str(self, *args)

    check_key = staticmethod(_common.ParameterValue_check_key)
    def warn_once(self, msg):
        cls = self.__class__
        if not hasattr(cls, '_warned'):
            cls._warned = set()
        if not msg in cls._warned:
            cls._warned.add(msg)
            print msg

    def value(self):
        val_type = self.type_str()
        if val_type == "string":
            return str(self)
        elif  val_type == "int":
            return int(self)
        elif val_type == "bool":
            return bool(self)
        elif val_type == "double":
            return float(self)
        else:
            raise TypeError, "unknown value type '%s' of parameter '%s'"%(val_type, self.key())

    def get_range(self):
        val_type = self.type_str()
        if val_type == "string":
            local_range = self._get_string_range()
            if len(local_range) == 0:
                return
            return local_range
        elif  val_type == "int":
            local_range = self._get_int_range()
            if local_range[0] == 0 and local_range[0] == local_range[0]:
                return
            return local_range
        elif val_type == "bool":
            return
        elif val_type == "double":
            from logging import DEBUG
            local_range = self._get_double_range()
            if local_range[0] == 0 and local_range[0] == local_range[0]:
                return
            return local_range
        else:
            raise TypeError, "unknown value type '%s' of parameter '%s'"%(val_type, self.key())

    def data(self):
        return self.value(), self.get_range(), self.access_count(), self.change_count()

ParameterValue.key = new_instancemethod(_common.ParameterValue_key,None,ParameterValue)
ParameterValue.description = new_instancemethod(_common.ParameterValue_description,None,ParameterValue)
ParameterValue.is_set = new_instancemethod(_common.ParameterValue_is_set,None,ParameterValue)
ParameterValue.reset = new_instancemethod(_common.ParameterValue_reset,None,ParameterValue)
ParameterValue.access_count = new_instancemethod(_common.ParameterValue_access_count,None,ParameterValue)
ParameterValue.change_count = new_instancemethod(_common.ParameterValue_change_count,None,ParameterValue)
ParameterValue.set_range = new_instancemethod(_common.ParameterValue_set_range,None,ParameterValue)
ParameterValue._get_int_range = new_instancemethod(_common.ParameterValue__get_int_range,None,ParameterValue)
ParameterValue._get_double_range = new_instancemethod(_common.ParameterValue__get_double_range,None,ParameterValue)
ParameterValue._get_string_range = new_instancemethod(_common.ParameterValue__get_string_range,None,ParameterValue)
ParameterValue._assign = new_instancemethod(_common.ParameterValue__assign,None,ParameterValue)
ParameterValue._assign_bool = new_instancemethod(_common.ParameterValue__assign_bool,None,ParameterValue)
ParameterValue.__int__ = new_instancemethod(_common.ParameterValue___int__,None,ParameterValue)
ParameterValue.__float__ = new_instancemethod(_common.ParameterValue___float__,None,ParameterValue)
ParameterValue.__str__ = new_instancemethod(_common.ParameterValue___str__,None,ParameterValue)
ParameterValue.type_str = new_instancemethod(_common.ParameterValue_type_str,None,ParameterValue)
ParameterValue.value_str = new_instancemethod(_common.ParameterValue_value_str,None,ParameterValue)
ParameterValue.range_str = new_instancemethod(_common.ParameterValue_range_str,None,ParameterValue)
ParameterValue.str = new_instancemethod(_common.ParameterValue_str,None,ParameterValue)
ParameterValue_swigregister = _common.ParameterValue_swigregister
ParameterValue_swigregister(ParameterValue)

def ParameterValue_check_key(*args):
  return _common.ParameterValue_check_key(*args)
ParameterValue_check_key = _common.ParameterValue_check_key

class IntParameter(ParameterValue):
    """
    Parameter with value type int

    """
    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): 
        """
        **Overloaded versions**

        * IntParameter\ (key)

          Create unset int-valued

        * IntParameter\ (key, value)

          Create int-valued parameter

        """
        _common.IntParameter_swiginit(self,_common.new_IntParameter(*args))
    __swig_destroy__ = _common.delete_IntParameter
    def _assign(self, *args):
        """
        Assignment

        """
        return _common.IntParameter__assign(self, *args)

IntParameter._assign = new_instancemethod(_common.IntParameter__assign,None,IntParameter)
IntParameter_swigregister = _common.IntParameter_swigregister
IntParameter_swigregister(IntParameter)

class DoubleParameter(ParameterValue):
    """
    Parameter with value type double

    """
    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): 
        """
        **Overloaded versions**

        * DoubleParameter\ (key)

          Create unset double-valued parameter

        * DoubleParameter\ (key, value)

          Create double-valued parameter

        """
        _common.DoubleParameter_swiginit(self,_common.new_DoubleParameter(*args))
    __swig_destroy__ = _common.delete_DoubleParameter
    def _assign(self, *args):
        """
        Assignment

        """
        return _common.DoubleParameter__assign(self, *args)

DoubleParameter._assign = new_instancemethod(_common.DoubleParameter__assign,None,DoubleParameter)
DoubleParameter_swigregister = _common.DoubleParameter_swigregister
DoubleParameter_swigregister(DoubleParameter)

class StringParameter(ParameterValue):
    """
    Parameter with value type string

    """
    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): 
        """
        **Overloaded versions**

        * StringParameter\ (key)

          Create unset string-valued parameter

        * StringParameter\ (key, value)

          Create string-valued parameter

        """
        _common.StringParameter_swiginit(self,_common.new_StringParameter(*args))
    __swig_destroy__ = _common.delete_StringParameter
    def _assign(self, *args):
        """
        **Overloaded versions**

        * operator=\ (value)

          Assignment

        * operator=\ (value)

          Assignment

        """
        return _common.StringParameter__assign(self, *args)

StringParameter._assign = new_instancemethod(_common.StringParameter__assign,None,StringParameter)
StringParameter_swigregister = _common.StringParameter_swigregister
StringParameter_swigregister(StringParameter)

class BoolParameter(ParameterValue):
    """
    Parameter with value type bool

    """
    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): 
        """
        **Overloaded versions**

        * BoolParameter\ (key)

          Create unset bool-valued parameter

        * BoolParameter\ (key, value)

          Create bool-valued parameter

        """
        _common.BoolParameter_swiginit(self,_common.new_BoolParameter(*args))
    __swig_destroy__ = _common.delete_BoolParameter
    def _assign_bool(self, *args):
        """
        Assignment

        """
        return _common.BoolParameter__assign_bool(self, *args)

BoolParameter._assign_bool = new_instancemethod(_common.BoolParameter__assign_bool,None,BoolParameter)
BoolParameter_swigregister = _common.BoolParameter_swigregister
BoolParameter_swigregister(BoolParameter)

class Parameters(object):
    """
    This class stores a set of parameters. Each parameter is
    identified by a unique string (the key) and a value of some
    given value type. Parameter sets can be nested at arbitrary
    depths.

    A parameter may be either int, double, string or boolean valued.

    Parameters may be added as follows:

      Parameters p("my_parameters");
      p.add("relative_tolerance",  1e-15);
      p.add("absolute_tolerance",  1e-15);
      p.add("gmres_restart",       30);
      p.add("monitor_convergence", false);

    Parameters may be changed as follows:

      p["gmres_restart"] = 50;

    Parameter values may be retrieved as follows:

      int gmres_restart = p["gmres_restart"];

    Parameter sets may be nested as follows:

      Parameters q("nested_parameters");
      p.add(q);

    Nested parameters may then be accessed by

      p("nested_parameters")["..."]

    Parameters may be nested at arbitrary depths.

    Parameters may be parsed from the command-line as follows:

      p.parse(argc, argv);

    Note: spaces in parameter keys are not allowed (to simplify
    usage from command-line).

    """
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_Parameters
    def __init__(self, *args): 
        """
        **Overloaded versions**

        * Parameters\ ("parameters")

          Create empty parameter set

        * Parameters\ (parameters)

          Copy constructor

        """
        _common.Parameters_swiginit(self,_common.new_Parameters(*args))
    def name(self, *args):
        """
        Return name for parameter set

        """
        return _common.Parameters_name(self, *args)

    def rename(self, *args):
        """
        Rename parameter set

        """
        return _common.Parameters_rename(self, *args)

    def clear(self, *args):
        """
        Clear parameter set

        """
        return _common.Parameters_clear(self, *args)

    def _add_bool(self, *args):
        """
        **Overloaded versions**

        * add\ (key)

          Add an unset parameter of type T. For example, to create a unset
          parameter of type bool, do parameters.add<bool>("my_setting")

        * add\ (key, min, max)

          Add an unset parameter of type T with allows parameters. For
          example, to create a unset parameter of type bool, do
          parameters.add<bool>("my_setting")

        * add\ (key, valid_values)

          Add an unset parameter of type T with allows parameters. For
          example, to create a unset parameter of type bool, do
          parameters.add<bool>("my_setting")

        * add\ (key, value)

          Add int-valued parameter

        * add\ (key, value, min_value, max_value)

          Add int-valued parameter with given range

        * add\ (key, value)

          Add double-valued parameter

        * add\ (key, value, min_value, max_value)

          Add double-valued parameter with given range

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value)

          Add bool-valued parameter

        * add\ (parameters)

          Add nested parameter set

        """
        return _common.Parameters__add_bool(self, *args)

    def _add(self, *args):
        """
        **Overloaded versions**

        * add\ (key)

          Add an unset parameter of type T. For example, to create a unset
          parameter of type bool, do parameters.add<bool>("my_setting")

        * add\ (key, min, max)

          Add an unset parameter of type T with allows parameters. For
          example, to create a unset parameter of type bool, do
          parameters.add<bool>("my_setting")

        * add\ (key, valid_values)

          Add an unset parameter of type T with allows parameters. For
          example, to create a unset parameter of type bool, do
          parameters.add<bool>("my_setting")

        * add\ (key, value)

          Add int-valued parameter

        * add\ (key, value, min_value, max_value)

          Add int-valued parameter with given range

        * add\ (key, value)

          Add double-valued parameter

        * add\ (key, value, min_value, max_value)

          Add double-valued parameter with given range

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value)

          Add string-valued parameter

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value, range)

          Add string-valued parameter with given range

        * add\ (key, value)

          Add bool-valued parameter

        * add\ (parameters)

          Add nested parameter set

        """
        return _common.Parameters__add(self, *args)

    def remove(self, *args):
        """
        Remove parameter or parameter set with given key

        """
        return _common.Parameters_remove(self, *args)

    def _get_parameter(self, *args):
        """
        **Overloaded versions**

        * operator[]\ (key)

          Return parameter for given key

        * operator[]\ (key)

          Return parameter for given key (const version)

        """
        return _common.Parameters__get_parameter(self, *args)

    def assign(self, *args):
        """
        Assignment operator

        """
        return _common.Parameters_assign(self, *args)

    def has_key(self, *args):
        """
        Check if parameter set has key (parameter or nested parameter set)

        """
        return _common.Parameters_has_key(self, *args)

    def has_parameter(self, *args):
        """
        Check if parameter set has given parameter

        """
        return _common.Parameters_has_parameter(self, *args)

    def has_parameter_set(self, *args):
        """
        Check if parameter set has given nested parameter set

        """
        return _common.Parameters_has_parameter_set(self, *args)

    def _get_parameter_keys(self, *args):
        """
        Return a vector of parameter keys

        """
        return _common.Parameters__get_parameter_keys(self, *args)

    def _get_parameter_set_keys(self, *args):
        """
        Return a vector of parameter set keys

        """
        return _common.Parameters__get_parameter_set_keys(self, *args)

    def str(self, *args):
        """
        Return informal string representation (pretty-print)

        """
        return _common.Parameters_str(self, *args)

    def _parse(self, *args):
        """Missing docstring"""
        return _common.Parameters__parse(self, *args)

    def add(self,*args):
        """Add a parameter to the parameter set"""
        if len(args) == 2 and isinstance(args[1],bool):
            self._add_bool(*args)
        else:
            self._add(*args)

    def parse(self,argv=None):
        "Parse command line arguments"
        if argv is None:
            import sys
            argv = sys.argv
        self._parse(argv)

    def keys(self):
        "Returns a list of the parameter keys"
        ret = self._get_parameter_keys()
        ret += self._get_parameter_set_keys()
        return ret

    def iterkeys(self):
        "Returns an iterator for the parameter keys"
        for key in self.keys():
            yield key

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

    def values(self):
        "Returns a list of the parameter values"
        return [self[key] for key in self.keys()]

    def itervalues(self):
        "Returns an iterator to the parameter values"
        return (self[key] for key in self.keys())

    def items(self):
        return zip(self.keys(),self.values())

    def iteritems(self):
        "Returns an iterator over the (key, value) items of the Parameters"
        for key, value in self.items():
            yield key, value

    def set_range(self, key, *arg):
        "Set the range for the given parameter"
        if key not in self._get_parameter_keys():
            raise KeyError, "no parameter with name '%s'"%key
        self._get_parameter(key).set_range(*arg)

    def get_range(self, key):
        "Get the range for the given parameter"
        if key not in self._get_parameter_keys():
            raise KeyError, "no parameter with name '%s'"%key
        return self._get_parameter(key).get_range()

    def __getitem__(self, key):
        "Return the parameter corresponding to the given key"
        if key in self._get_parameter_keys():
            return self._get_parameter(key).value()

        if key in self._get_parameter_set_keys():
            return self._get_parameter_set(key)

        raise KeyError, "'%s'"%key

    def __setitem__(self, key, value):
        "Set the parameter 'key', with given 'value'"
        if key not in self._get_parameter_keys():
            raise KeyError, "'%s' is not a parameter"%key
        if not isinstance(value,(int,str,float,bool)):
            raise TypeError, "can only set 'int', 'bool', 'float' and 'str' parameters"
        par = self._get_parameter(key)
        if isinstance(value,bool):
            par._assign_bool(value)
        else:
            par._assign(value)

    def update(self, other):
        "A recursive update that handles parameter subsets correctly."
        if not isinstance(other,(Parameters, dict)):
            raise TypeError, "expected a 'dict' or a '%s'"%Parameters.__name__
        for key, other_value in other.iteritems():
            self_value  = self[key]
            if isinstance(self_value, Parameters):
                self_value.update(other_value)
            else:
                setattr(self, key, other_value)

    def to_dict(self):
        """Convert the Parameters to a dict"""
        ret = {}
        for key, value in self.iteritems():
            if isinstance(value, Parameters):
                ret[key] = value.to_dict()
            else:
                ret[key] = value
        return ret

    def copy(self):
        "Return a copy of it self"
        return Parameters(self)

    def option_string(self):
        "Return an option string representation of the Parameters"
        def option_list(parent,basename):
            ret_list = []
            for key, value in parent.iteritems():
                if isinstance(value, Parameters):
                    ret_list.extend(option_list(value,basename + key + '.'))
                else:
                    ret_list.append(basename + key + " " + str(value))
            return ret_list

        return " ".join(option_list(self,"--"))

    def __str__(self):
        "p.__str__() <==> str(x)"
        return self.str(False)

    __getattr__ = __getitem__
    __setattr__ = __setitem__

    def iterdata(self):
        """Returns an iterator of a tuple of a parameter key together with its value"""
        for key in self.iterkeys():
            yield key, self.get(key)

    def get(self, key):
        """Return all data available for a certain parameter

        The data is returned in a tuple:
        value, range, access_count, change_count = parameters.get('name')
        """
        if key in self._get_parameter_keys():
            return self._get_parameter(key).data()

        if key in self._get_parameter_set_keys():
            return self._get_parameter_set(key)

        raise KeyError, "'%s'"%key


Parameters.name = new_instancemethod(_common.Parameters_name,None,Parameters)
Parameters.rename = new_instancemethod(_common.Parameters_rename,None,Parameters)
Parameters.clear = new_instancemethod(_common.Parameters_clear,None,Parameters)
Parameters._add_bool = new_instancemethod(_common.Parameters__add_bool,None,Parameters)
Parameters._add = new_instancemethod(_common.Parameters__add,None,Parameters)
Parameters.remove = new_instancemethod(_common.Parameters_remove,None,Parameters)
Parameters._get_parameter = new_instancemethod(_common.Parameters__get_parameter,None,Parameters)
Parameters._get_parameter_set = new_instancemethod(_common.Parameters__get_parameter_set,None,Parameters)
Parameters.assign = new_instancemethod(_common.Parameters_assign,None,Parameters)
Parameters.has_key = new_instancemethod(_common.Parameters_has_key,None,Parameters)
Parameters.has_parameter = new_instancemethod(_common.Parameters_has_parameter,None,Parameters)
Parameters.has_parameter_set = new_instancemethod(_common.Parameters_has_parameter_set,None,Parameters)
Parameters._get_parameter_keys = new_instancemethod(_common.Parameters__get_parameter_keys,None,Parameters)
Parameters._get_parameter_set_keys = new_instancemethod(_common.Parameters__get_parameter_set_keys,None,Parameters)
Parameters.str = new_instancemethod(_common.Parameters_str,None,Parameters)
Parameters.find_parameter = new_instancemethod(_common.Parameters_find_parameter,None,Parameters)
Parameters.find_parameter_set = new_instancemethod(_common.Parameters_find_parameter_set,None,Parameters)
Parameters._parse = new_instancemethod(_common.Parameters__parse,None,Parameters)
Parameters_swigregister = _common.Parameters_swigregister
Parameters_swigregister(Parameters)

class GlobalParameters(Parameters):
    """
    This class defines the global DOLFIN parameter database.

    """
    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): 
        """
        Constructor

        """
        _common.GlobalParameters_swiginit(self,_common.new_GlobalParameters(*args))
    __swig_destroy__ = _common.delete_GlobalParameters
    def default_parameters(*args):
        """
        Default parameter values

        """
        return _common.GlobalParameters_default_parameters(*args)

    default_parameters = staticmethod(default_parameters)
GlobalParameters_swigregister = _common.GlobalParameters_swigregister
GlobalParameters_swigregister(GlobalParameters)
cvar = _common.cvar

def GlobalParameters_default_parameters(*args):
  """
    Default parameter values

    """
  return _common.GlobalParameters_default_parameters(*args)

old_init = Parameters.__init__
def __new_Parameter_init__(self,*args,**kwargs):
    """Initialize Parameters

    Usage:

    Parameters()
       create empty parameter set

    Parameters(name)
       create empty parameter set with given name

    Parameters(other_parameters)
       create copy of parameter set

    Parameters(name, dim=3, tol=0.1, foo="Foo")
       create parameter set with given parameters

    Parameters(name, dim=(3, 0, 4), foo=("Foo", ["Foo", "Bar"])
       create parameter set with given parameters and ranges
    """

    if len(args) == 0:
        old_init(self, "parameters")
    elif len(args) == 1 and isinstance(args[0], (str,type(self))):
        old_init(self, args[0])
    else:
        raise TypeError, "expected a single optional argument of type 'str' or ''"%type(self).__name__
    if len(kwargs) == 0:
        return

    from numpy import isscalar
    for key, value in kwargs.iteritems():
        if isinstance(value,type(self)):
            self.add(value)
        elif isinstance(value,tuple):
            if isscalar(value[0]) and len(value) == 3:
                self.add(key, *value)
            elif isinstance(value[0], str) and len(value) == 2:
                if not isinstance(value[1], list):
                    raise TypeError, "expected a list as second item of tuple, when first is a 'str'"
                self.add(key, *value)
            else:
                raise TypeError,"expected a range tuple of size 2 for 'str' values and 3 for scalars"
        else:
            self.add(key,value)

Parameters.__init__ = __new_Parameter_init__



def get_global_parameters(*args):
  return _common.get_global_parameters(*args)
get_global_parameters = _common.get_global_parameters
parameters = _common.get_global_parameters()
del _common.get_global_parameters


def _info(*args):
  """
    **Overloaded versions**

    * info\ (msg, ...)

      The DOLFIN log system provides the following set of functions for
      uniform handling of log messages, warnings and errors. In addition,
      macros are provided for debug messages and dolfin_assertions.
      
      Only messages with a debug level higher than or equal to the current
      log level are printed (the default being zero). Logging may also be
      turned off by calling set_log_active(false).
      Print message

    * info\ (parameters, verbose=false)

      Print parameter (using output of str() method)

    * info\ (variable, verbose=false)

      Print variable (using output of str() method)

    """
  return _common._info(*args)

def info_stream(*args):
  """
    Print message to stream

    """
  return _common.info_stream(*args)

def info_underline(*args):
  """
    Print underlined message

    """
  return _common.info_underline(*args)

def warning(*args):
  """
    Print warning

    """
  return _common.warning(*args)

def error(*args):
  """
    Print error message and throw an exception.
    Note to developers: this function should not be used internally
    in DOLFIN. Use the more informative dolfin_error instead.

    """
  return _common.error(*args)

def dolfin_error(*args):
  """
    Print error message. Prefer this to the above generic error message.

    *Arguments*
        location (str)
            Name of the file from which the error message was generated.
        task (str)
            Name of the task that failed.
            Note that this string should begin with lowercase.
            Note that this string should not be punctuated.
        reason (str)
            A format string explaining the reason for the failure.
            Note that this string should begin with uppercase.
            Note that this string should not be punctuated.
            Note that this string may contain printf style formatting.
        ... (primitive types like int, uint, double, bool)
            Optional arguments for the format string.

    Developers should read the file dolfin/log/README in the DOLFIN
    source tree for further notes about the use of this function.

    """
  return _common.dolfin_error(*args)

def deprecation(*args):
  """
    Issue deprecation warning for removed feature

    *Arguments*
        feature (str)
           Name of the feature that has been removed.
        version (str)
           Version number of the release in which the feature was removed.
        message (str)
           A format string explaining the deprecation.

    """
  return _common.deprecation(*args)

def log(*args):
  """
    Print message at given debug level

    """
  return _common.log(*args)

def begin(*args):
  """
    **Overloaded versions**

    * begin\ (msg, ...)

      Begin task (increase indentation level)

    * begin\ (debug_level, msg, ...)

      Begin task (increase indentation level)

    """
  return _common.begin(*args)

def end(*args):
  """
    End task (decrease indentation level)

    """
  return _common.end(*args)

def set_log_active(*args):
  """
    Turn logging on or off

    """
  return _common.set_log_active(*args)

def set_log_level(*args):
  """
    Set log level

    """
  return _common.set_log_level(*args)

def set_output_stream(*args):
  """
    Set output stream

    """
  return _common.set_output_stream(*args)

def get_log_level(*args):
  """
    Get log level

    """
  return _common.get_log_level(*args)

def monitor_memory_usage(*args):
  """
    Monitor memory usage. Call this function at the start of a
    program to continuously monitor the memory usage of the process.

    """
  return _common.monitor_memory_usage(*args)

def not_working_in_parallel(*args):
  """
    Report that functionality has not (yet) been implemented to work
    in parallel

    """
  return _common.not_working_in_parallel(*args)

def __debug(*args):
  return _common.__debug(*args)
__debug = _common.__debug

def __dolfin_assert(*args):
  return _common.__dolfin_assert(*args)
__dolfin_assert = _common.__dolfin_assert
class Event(object):
    """
    A event is a string message which is displayed
    only a limited number of times.

    *Example*
        .. code-block:: python
        
            >>> event = dolfin.Event("System is stiff, damping is needed.", 3)
            >>> for i in range(10):
            ...     if i > 7:
            ...         print i
            ...         event()

    """
    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): 
        """
        Constructor

        """
        _common.Event_swiginit(self,_common.new_Event(*args))
    __swig_destroy__ = _common.delete_Event
    def count(self, *args):
        """
        Display count

        """
        return _common.Event_count(self, *args)

    def maxcount(self, *args):
        """
        Maximum display count

        """
        return _common.Event_maxcount(self, *args)

Event.__call__ = new_instancemethod(_common.Event___call__,None,Event)
Event.count = new_instancemethod(_common.Event_count,None,Event)
Event.maxcount = new_instancemethod(_common.Event_maxcount,None,Event)
Event_swigregister = _common.Event_swigregister
Event_swigregister(Event)

class Progress(object):
    """
    This class provides a simple way to create and update progress
    bars during a computation.

    *Example*
        A progress bar may be used either in an iteration with a known number
        of steps:
        
        .. code-block:: python
        
            >>> n = 1000000
            >>> p = dolfin.Progress("Iterating...", n)
            >>> for i in range(n):
            ...     p += 1
        
        or in an iteration with an unknown number of steps:
        
        .. code-block:: python
        
            >>> pr = dolfin.Progress("Iterating")
            >>> t = 0.0
            >>> n = 1000000.0
            >>> while t < n:
            ...     t += 1.0
            ...     p += t/n

    """
    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): 
        """
        **Overloaded versions**

        * Progress\ (title, n)

          Create progress bar with a known number of steps
          
          *Arguments*
              title (str)
                  The title.
              n (int)
                  Number of steps.

        * Progress\ (title)

          Create progress bar with an unknown number of steps
          
          *Arguments*
              title (str)
                  The title.

        """
        _common.Progress_swiginit(self,_common.new_Progress(*args))
    __swig_destroy__ = _common.delete_Progress
    def _add(self, *args):
        """Missing docstring"""
        return _common.Progress__add(self, *args)

    def _set(self, *args):
        """Missing docstring"""
        return _common.Progress__set(self, *args)

    def __iadd__(self, other):
        if isinstance(other, int):
            self._add(other)
        elif isinstance(other, float):
            self._set(other)
        return self

    def update(self, other):
        "Update the progress with given number"
        if isinstance(other, float):
            self._set(other)

Progress._add = new_instancemethod(_common.Progress__add,None,Progress)
Progress._set = new_instancemethod(_common.Progress__set,None,Progress)
Progress_swigregister = _common.Progress_swigregister
Progress_swigregister(Progress)

class Table(Variable):
    """
    This class provides storage and pretty-printing for tables.
    Example usage:

      Table table("Timings");

      table("uBLAS",  "Assemble") = 0.010;
      table("uBLAS",  "Solve")    = 0.020;
      table("PETSc",  "Assemble") = 0.011;
      table("PETSc",  "Solve")    = 0.019;
      table("Epetra", "Assemble") = 0.012;
      table("Epetra", "Solve")    = 0.018;

      info(table);

    """
    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): 
        """
        Create empty table

        """
        _common.Table_swiginit(self,_common.new_Table(*args))
    __swig_destroy__ = _common.delete_Table
    def set(self, *args):
        """
        **Overloaded versions**

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        * set\ (row, col, value)

          Set value of table entry

        """
        return _common.Table_set(self, *args)

    def get(self, *args):
        """
        Get value of table entry

        """
        return _common.Table_get(self, *args)

    def get_value(self, *args):
        """
        Get value of table entry

        """
        return _common.Table_get_value(self, *args)

    def title(self, *args):
        """
        Return table title

        """
        return _common.Table_title(self, *args)

    def str_latex(self, *args):
        """
        Return informal string representation for LaTeX

        """
        return _common.Table_str_latex(self, *args)

Table.__call__ = new_instancemethod(_common.Table___call__,None,Table)
Table.set = new_instancemethod(_common.Table_set,None,Table)
Table.get = new_instancemethod(_common.Table_get,None,Table)
Table.get_value = new_instancemethod(_common.Table_get_value,None,Table)
Table.title = new_instancemethod(_common.Table_title,None,Table)
Table.str_latex = new_instancemethod(_common.Table_str_latex,None,Table)
Table_swigregister = _common.Table_swigregister
Table_swigregister(Table)

class TableEntry(object):
    """
    This class represents an entry in a Table

    """
    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): 
        """
        Create table entry

        """
        _common.TableEntry_swiginit(self,_common.new_TableEntry(*args))
    __swig_destroy__ = _common.delete_TableEntry
TableEntry_swigregister = _common.TableEntry_swigregister
TableEntry_swigregister(TableEntry)

CRITICAL = _common.CRITICAL
ERROR = _common.ERROR
WARNING = _common.WARNING
INFO = _common.INFO
PROGRESS = _common.PROGRESS
TRACE = _common.TRACE
DBG = _common.DBG
def debug(message):
    import traceback
    file, line, func, txt = traceback.extract_stack(None, 2)[0]
    __debug(file, line, func, message)

def info(object, verbose=False):
    """Print string or object.

    *Arguments*
        object
            A string or a DOLFIN object (:py:class:`Variable <dolfin.cpp.Variable>`
            or :py:class:`Parameters <dolfin.cpp.Parameters>`)
        verbose
            An optional argument that indicates whether verbose object data
            should be printed. If False, a short one-line summary is printed.
            If True, verbose and sometimes very exhaustive object data are
            printed.
    """

    if isinstance(object, (Variable, Parameters)):
        _info(object.str(verbose))
    else:
        _info(object)