text: # This file was automatically generated by SWIG (http://www.swig.org).
  # Version 4.0.2
  #
  # Do not make changes to this file unless you know what you are doing--modify
  # the SWIG interface file instead.
  
  from sys import version_info as _swig_python_version_info
  if _swig_python_version_info < (2, 7, 0):
      raise RuntimeError("Python 2.7 or later required")
  
  # Import the low-level C/C++ module
  if __package__ or "." in __name__:
      from . import _densemat
  else:
      import _densemat
  
  try:
      import builtins as __builtin__
  except ImportError:
      import __builtin__
  
  _swig_new_instance_method = _densemat.SWIG_PyInstanceMethod_New
  _swig_new_static_method = _densemat.SWIG_PyStaticMethod_New
  
  def _swig_repr(self):
      try:
          strthis = "proxy of " + self.this.__repr__()
      except __builtin__.Exception:
          strthis = ""
      return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
  
  
  def _swig_setattr_nondynamic_instance_variable(set):
      def set_instance_attr(self, name, value):
          if name == "thisown":
              self.this.own(value)
          elif name == "this":
              set(self, name, value)
          elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
              set(self, name, value)
          else:
              raise AttributeError("You cannot add instance attributes to %s" % self)
      return set_instance_attr
  
  
  def _swig_setattr_nondynamic_class_variable(set):
      def set_class_attr(cls, name, value):
          if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
              set(cls, name, value)
          else:
              raise AttributeError("You cannot add class attributes to %s" % cls)
      return set_class_attr
  
  
  def _swig_add_metaclass(metaclass):
      """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
      def wrapper(cls):
          return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
      return wrapper
  
  
  class _SwigNonDynamicMeta(type):
      """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
      __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
  
  
  import weakref
  
  import mfem._ser.mem_manager
  import mfem._ser.array
  import mfem._ser.vector
  import mfem._ser.operators
  import mfem._ser.matrix
  class DenseMatrix(mfem._ser.matrix.Matrix):
      r"""Proxy of C++ mfem::DenseMatrix class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(DenseMatrix self) -> DenseMatrix
          __init__(DenseMatrix self, DenseMatrix arg2) -> DenseMatrix
          __init__(DenseMatrix self, int s) -> DenseMatrix
          __init__(DenseMatrix self, int m, int n) -> DenseMatrix
          __init__(DenseMatrix self, DenseMatrix mat, char ch) -> DenseMatrix
          __init__(DenseMatrix self, double * d, int h, int w) -> DenseMatrix
          """
          _densemat.DenseMatrix_swiginit(self, _densemat.new_DenseMatrix(*args))
  
      def UseExternalData(self, d, h, w):
          r"""UseExternalData(DenseMatrix self, double * d, int h, int w)"""
          return _densemat.DenseMatrix_UseExternalData(self, d, h, w)
      UseExternalData = _swig_new_instance_method(_densemat.DenseMatrix_UseExternalData)
  
      def Reset(self, d, h, w):
          r"""Reset(DenseMatrix self, double * d, int h, int w)"""
          return _densemat.DenseMatrix_Reset(self, d, h, w)
      Reset = _swig_new_instance_method(_densemat.DenseMatrix_Reset)
  
      def ClearExternalData(self):
          r"""ClearExternalData(DenseMatrix self)"""
          return _densemat.DenseMatrix_ClearExternalData(self)
      ClearExternalData = _swig_new_instance_method(_densemat.DenseMatrix_ClearExternalData)
  
      def Clear(self):
          r"""Clear(DenseMatrix self)"""
          return _densemat.DenseMatrix_Clear(self)
      Clear = _swig_new_instance_method(_densemat.DenseMatrix_Clear)
  
      def Size(self):
          r"""Size(DenseMatrix self) -> int"""
          return _densemat.DenseMatrix_Size(self)
      Size = _swig_new_instance_method(_densemat.DenseMatrix_Size)
  
      def SetSize(self, *args):
          r"""
          SetSize(DenseMatrix self, int s)
          SetSize(DenseMatrix self, int h, int w)
          """
          return _densemat.DenseMatrix_SetSize(self, *args)
      SetSize = _swig_new_instance_method(_densemat.DenseMatrix_SetSize)
  
      def Data(self):
          r"""Data(DenseMatrix self) -> double *"""
          return _densemat.DenseMatrix_Data(self)
      Data = _swig_new_instance_method(_densemat.DenseMatrix_Data)
  
      def GetData(self):
          r"""GetData(DenseMatrix self) -> double *"""
          return _densemat.DenseMatrix_GetData(self)
      GetData = _swig_new_instance_method(_densemat.DenseMatrix_GetData)
  
      def GetMemory(self, *args):
          r"""
          GetMemory(DenseMatrix self) -> mfem::Memory< double >
          GetMemory(DenseMatrix self) -> mfem::Memory< double > const &
          """
          return _densemat.DenseMatrix_GetMemory(self, *args)
      GetMemory = _swig_new_instance_method(_densemat.DenseMatrix_GetMemory)
  
      def OwnsData(self):
          r"""OwnsData(DenseMatrix self) -> bool"""
          return _densemat.DenseMatrix_OwnsData(self)
      OwnsData = _swig_new_instance_method(_densemat.DenseMatrix_OwnsData)
  
      def __call__(self, *args):
          r"""
          __call__(DenseMatrix self, int i, int j) -> double
          __call__(DenseMatrix self, int i, int j) -> double const &
          """
          return _densemat.DenseMatrix___call__(self, *args)
      __call__ = _swig_new_instance_method(_densemat.DenseMatrix___call__)
  
      def __mul__(self, m):
          r"""__mul__(DenseMatrix self, DenseMatrix m) -> double"""
          return _densemat.DenseMatrix___mul__(self, m)
      __mul__ = _swig_new_instance_method(_densemat.DenseMatrix___mul__)
  
      def Trace(self):
          r"""Trace(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_Trace(self)
      Trace = _swig_new_instance_method(_densemat.DenseMatrix_Trace)
  
      def Elem(self, *args):
          r"""
          Elem(DenseMatrix self, int i, int j) -> double
          Elem(DenseMatrix self, int i, int j) -> double const &
          """
          return _densemat.DenseMatrix_Elem(self, *args)
      Elem = _swig_new_instance_method(_densemat.DenseMatrix_Elem)
  
      def Mult(self, *args):
          r"""
          Mult(DenseMatrix self, double const * x, double * y)
          Mult(DenseMatrix self, Vector x, Vector y)
          """
          return _densemat.DenseMatrix_Mult(self, *args)
      Mult = _swig_new_instance_method(_densemat.DenseMatrix_Mult)
  
      def MultTranspose(self, *args):
          r"""
          MultTranspose(DenseMatrix self, double const * x, double * y)
          MultTranspose(DenseMatrix self, Vector x, Vector y)
          """
          return _densemat.DenseMatrix_MultTranspose(self, *args)
      MultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_MultTranspose)
  
      def AddMult(self, x, y):
          r"""AddMult(DenseMatrix self, Vector x, Vector y)"""
          return _densemat.DenseMatrix_AddMult(self, x, y)
      AddMult = _swig_new_instance_method(_densemat.DenseMatrix_AddMult)
  
      def AddMultTranspose(self, x, y):
          r"""AddMultTranspose(DenseMatrix self, Vector x, Vector y)"""
          return _densemat.DenseMatrix_AddMultTranspose(self, x, y)
      AddMultTranspose = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose)
  
      def AddMult_a(self, a, x, y):
          r"""AddMult_a(DenseMatrix self, double a, Vector x, Vector y)"""
          return _densemat.DenseMatrix_AddMult_a(self, a, x, y)
      AddMult_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMult_a)
  
      def AddMultTranspose_a(self, a, x, y):
          r"""AddMultTranspose_a(DenseMatrix self, double a, Vector x, Vector y)"""
          return _densemat.DenseMatrix_AddMultTranspose_a(self, a, x, y)
      AddMultTranspose_a = _swig_new_instance_method(_densemat.DenseMatrix_AddMultTranspose_a)
  
      def LeftScaling(self, s):
          r"""LeftScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_LeftScaling(self, s)
      LeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_LeftScaling)
  
      def InvLeftScaling(self, s):
          r"""InvLeftScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_InvLeftScaling(self, s)
      InvLeftScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvLeftScaling)
  
      def RightScaling(self, s):
          r"""RightScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_RightScaling(self, s)
      RightScaling = _swig_new_instance_method(_densemat.DenseMatrix_RightScaling)
  
      def InvRightScaling(self, s):
          r"""InvRightScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_InvRightScaling(self, s)
      InvRightScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvRightScaling)
  
      def SymmetricScaling(self, s):
          r"""SymmetricScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_SymmetricScaling(self, s)
      SymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_SymmetricScaling)
  
      def InvSymmetricScaling(self, s):
          r"""InvSymmetricScaling(DenseMatrix self, Vector s)"""
          return _densemat.DenseMatrix_InvSymmetricScaling(self, s)
      InvSymmetricScaling = _swig_new_instance_method(_densemat.DenseMatrix_InvSymmetricScaling)
  
      def InnerProduct(self, *args):
          r"""
          InnerProduct(DenseMatrix self, double const * x, double const * y) -> double
          InnerProduct(DenseMatrix self, Vector x, Vector y) -> double
          """
          return _densemat.DenseMatrix_InnerProduct(self, *args)
      InnerProduct = _swig_new_instance_method(_densemat.DenseMatrix_InnerProduct)
  
      def Inverse(self):
          r"""Inverse(DenseMatrix self) -> MatrixInverse"""
          return _densemat.DenseMatrix_Inverse(self)
      Inverse = _swig_new_instance_method(_densemat.DenseMatrix_Inverse)
  
      def Invert(self):
          r"""Invert(DenseMatrix self)"""
          return _densemat.DenseMatrix_Invert(self)
      Invert = _swig_new_instance_method(_densemat.DenseMatrix_Invert)
  
      def SquareRootInverse(self):
          r"""SquareRootInverse(DenseMatrix self)"""
          return _densemat.DenseMatrix_SquareRootInverse(self)
      SquareRootInverse = _swig_new_instance_method(_densemat.DenseMatrix_SquareRootInverse)
  
      def Det(self):
          r"""Det(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_Det(self)
      Det = _swig_new_instance_method(_densemat.DenseMatrix_Det)
  
      def Weight(self):
          r"""Weight(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_Weight(self)
      Weight = _swig_new_instance_method(_densemat.DenseMatrix_Weight)
  
      def Set(self, *args):
          r"""
          Set(DenseMatrix self, double alpha, double const * A)
          Set(DenseMatrix self, double alpha, DenseMatrix A)
          """
          return _densemat.DenseMatrix_Set(self, *args)
      Set = _swig_new_instance_method(_densemat.DenseMatrix_Set)
  
      def Add(self, c, A):
          r"""Add(DenseMatrix self, double const c, DenseMatrix A)"""
          return _densemat.DenseMatrix_Add(self, c, A)
      Add = _swig_new_instance_method(_densemat.DenseMatrix_Add)
  
      def __iadd__(self, v):
          ret = _densemat.DenseMatrix___iadd__(self, v)
          ret.thisown = self.thisown
          self.thisown = 0                  
          return ret
  
  
  
      def __isub__(self, v):
          ret = _densemat.DenseMatrix___isub__(self, v)  
          ret.thisown = self.thisown
          self.thisown = 0            
          return ret
  
  
  
      def __imul__(self, v):
          ret = _densemat.DenseMatrix___imul__(self, v)  
          ret.thisown = self.thisown
          self.thisown = 0            
          return ret
  
  
  
      def Neg(self):
          r"""Neg(DenseMatrix self)"""
          return _densemat.DenseMatrix_Neg(self)
      Neg = _swig_new_instance_method(_densemat.DenseMatrix_Neg)
  
      def Norm2(self, v):
          r"""Norm2(DenseMatrix self, double * v)"""
          return _densemat.DenseMatrix_Norm2(self, v)
      Norm2 = _swig_new_instance_method(_densemat.DenseMatrix_Norm2)
  
      def MaxMaxNorm(self):
          r"""MaxMaxNorm(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_MaxMaxNorm(self)
      MaxMaxNorm = _swig_new_instance_method(_densemat.DenseMatrix_MaxMaxNorm)
  
      def FNorm(self):
          r"""FNorm(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_FNorm(self)
      FNorm = _swig_new_instance_method(_densemat.DenseMatrix_FNorm)
  
      def FNorm2(self):
          r"""FNorm2(DenseMatrix self) -> double"""
          return _densemat.DenseMatrix_FNorm2(self)
      FNorm2 = _swig_new_instance_method(_densemat.DenseMatrix_FNorm2)
  
      def Eigenvalues(self, *args):
          r"""
          Eigenvalues(DenseMatrix self, Vector ev)
          Eigenvalues(DenseMatrix self, Vector ev, DenseMatrix evect)
          Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev)
          Eigenvalues(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)
          """
          return _densemat.DenseMatrix_Eigenvalues(self, *args)
      Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_Eigenvalues)
  
      def Eigensystem(self, *args):
          r"""
          Eigensystem(DenseMatrix self, Vector ev, DenseMatrix evect)
          Eigensystem(DenseMatrix self, DenseMatrix b, Vector ev, DenseMatrix evect)
          """
          return _densemat.DenseMatrix_Eigensystem(self, *args)
      Eigensystem = _swig_new_instance_method(_densemat.DenseMatrix_Eigensystem)
  
      def SingularValues(self, sv):
          r"""SingularValues(DenseMatrix self, Vector sv)"""
          return _densemat.DenseMatrix_SingularValues(self, sv)
      SingularValues = _swig_new_instance_method(_densemat.DenseMatrix_SingularValues)
  
      def Rank(self, tol):
          r"""Rank(DenseMatrix self, double tol) -> int"""
          return _densemat.DenseMatrix_Rank(self, tol)
      Rank = _swig_new_instance_method(_densemat.DenseMatrix_Rank)
  
      def CalcSingularvalue(self, i):
          r"""CalcSingularvalue(DenseMatrix self, int const i) -> double"""
          return _densemat.DenseMatrix_CalcSingularvalue(self, i)
      CalcSingularvalue = _swig_new_instance_method(_densemat.DenseMatrix_CalcSingularvalue)
  
      def CalcEigenvalues(self, _lambda, vec):
          r"""CalcEigenvalues(DenseMatrix self, double * _lambda, double * vec)"""
          return _densemat.DenseMatrix_CalcEigenvalues(self, _lambda, vec)
      CalcEigenvalues = _swig_new_instance_method(_densemat.DenseMatrix_CalcEigenvalues)
  
      def GetRow(self, r, row):
          r"""GetRow(DenseMatrix self, int r, Vector row)"""
          return _densemat.DenseMatrix_GetRow(self, r, row)
      GetRow = _swig_new_instance_method(_densemat.DenseMatrix_GetRow)
  
      def GetColumn(self, *args):
          r"""
          GetColumn(DenseMatrix self, int c, Vector col)
          GetColumn(DenseMatrix self, int col) -> double
          GetColumn(DenseMatrix self, int col) -> double const *
          """
          return _densemat.DenseMatrix_GetColumn(self, *args)
      GetColumn = _swig_new_instance_method(_densemat.DenseMatrix_GetColumn)
  
      def GetColumnReference(self, c, col):
          r"""GetColumnReference(DenseMatrix self, int c, Vector col)"""
          return _densemat.DenseMatrix_GetColumnReference(self, c, col)
      GetColumnReference = _swig_new_instance_method(_densemat.DenseMatrix_GetColumnReference)
  
      def SetRow(self, *args):
          r"""
          SetRow(DenseMatrix self, int r, double const * row)
          SetRow(DenseMatrix self, int r, Vector row)
          SetRow(DenseMatrix self, int row, double value)
          """
          return _densemat.DenseMatrix_SetRow(self, *args)
      SetRow = _swig_new_instance_method(_densemat.DenseMatrix_SetRow)
  
      def SetCol(self, *args):
          r"""
          SetCol(DenseMatrix self, int c, double const * col)
          SetCol(DenseMatrix self, int c, Vector col)
          SetCol(DenseMatrix self, int col, double value)
          """
          return _densemat.DenseMatrix_SetCol(self, *args)
      SetCol = _swig_new_instance_method(_densemat.DenseMatrix_SetCol)
  
      def GetDiag(self, d):
          r"""GetDiag(DenseMatrix self, Vector d)"""
          return _densemat.DenseMatrix_GetDiag(self, d)
      GetDiag = _swig_new_instance_method(_densemat.DenseMatrix_GetDiag)
  
      def Getl1Diag(self, l):
          r"""Getl1Diag(DenseMatrix self, Vector l)"""
          return _densemat.DenseMatrix_Getl1Diag(self, l)
      Getl1Diag = _swig_new_instance_method(_densemat.DenseMatrix_Getl1Diag)
  
      def GetRowSums(self, l):
          r"""GetRowSums(DenseMatrix self, Vector l)"""
          return _densemat.DenseMatrix_GetRowSums(self, l)
      GetRowSums = _swig_new_instance_method(_densemat.DenseMatrix_GetRowSums)
  
      def Diag(self, *args):
          r"""
          Diag(DenseMatrix self, double c, int n)
          Diag(DenseMatrix self, double * diag, int n)
          """
          return _densemat.DenseMatrix_Diag(self, *args)
      Diag = _swig_new_instance_method(_densemat.DenseMatrix_Diag)
  
      def Transpose(self, *args):
          r"""
          Transpose(DenseMatrix self)
          Transpose(DenseMatrix self, DenseMatrix A)
          """
          return _densemat.DenseMatrix_Transpose(self, *args)
      Transpose = _swig_new_instance_method(_densemat.DenseMatrix_Transpose)
  
      def Symmetrize(self):
          r"""Symmetrize(DenseMatrix self)"""
          return _densemat.DenseMatrix_Symmetrize(self)
      Symmetrize = _swig_new_instance_method(_densemat.DenseMatrix_Symmetrize)
  
      def Lump(self):
          r"""Lump(DenseMatrix self)"""
          return _densemat.DenseMatrix_Lump(self)
      Lump = _swig_new_instance_method(_densemat.DenseMatrix_Lump)
  
      def GradToCurl(self, curl):
          r"""GradToCurl(DenseMatrix self, DenseMatrix curl)"""
          return _densemat.DenseMatrix_GradToCurl(self, curl)
      GradToCurl = _swig_new_instance_method(_densemat.DenseMatrix_GradToCurl)
  
      def GradToDiv(self, div):
          r"""GradToDiv(DenseMatrix self, Vector div)"""
          return _densemat.DenseMatrix_GradToDiv(self, div)
      GradToDiv = _swig_new_instance_method(_densemat.DenseMatrix_GradToDiv)
  
      def CopyRows(self, A, row1, row2):
          r"""CopyRows(DenseMatrix self, DenseMatrix A, int row1, int row2)"""
          return _densemat.DenseMatrix_CopyRows(self, A, row1, row2)
      CopyRows = _swig_new_instance_method(_densemat.DenseMatrix_CopyRows)
  
      def CopyCols(self, A, col1, col2):
          r"""CopyCols(DenseMatrix self, DenseMatrix A, int col1, int col2)"""
          return _densemat.DenseMatrix_CopyCols(self, A, col1, col2)
      CopyCols = _swig_new_instance_method(_densemat.DenseMatrix_CopyCols)
  
      def CopyMNt(self, A, row_offset, col_offset):
          r"""CopyMNt(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)"""
          return _densemat.DenseMatrix_CopyMNt(self, A, row_offset, col_offset)
      CopyMNt = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNt)
  
      def CopyMN(self, *args):
          r"""
          CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco)
          CopyMN(DenseMatrix self, DenseMatrix A, int row_offset, int col_offset)
          CopyMN(DenseMatrix self, DenseMatrix A, int m, int n, int Aro, int Aco, int row_offset, int col_offset)
          """
          return _densemat.DenseMatrix_CopyMN(self, *args)
      CopyMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyMN)
  
      def CopyMNDiag(self, *args):
          r"""
          CopyMNDiag(DenseMatrix self, double c, int n, int row_offset, int col_offset)
          CopyMNDiag(DenseMatrix self, double * diag, int n, int row_offset, int col_offset)
          """
          return _densemat.DenseMatrix_CopyMNDiag(self, *args)
      CopyMNDiag = _swig_new_instance_method(_densemat.DenseMatrix_CopyMNDiag)
  
      def CopyExceptMN(self, A, m, n):
          r"""CopyExceptMN(DenseMatrix self, DenseMatrix A, int m, int n)"""
          return _densemat.DenseMatrix_CopyExceptMN(self, A, m, n)
      CopyExceptMN = _swig_new_instance_method(_densemat.DenseMatrix_CopyExceptMN)
  
      def AddMatrix(self, *args):
          r"""
          AddMatrix(DenseMatrix self, DenseMatrix A, int ro, int co)
          AddMatrix(DenseMatrix self, double a, DenseMatrix A, int ro, int co)
          """
          return _densemat.DenseMatrix_AddMatrix(self, *args)
      AddMatrix = _swig_new_instance_method(_densemat.DenseMatrix_AddMatrix)
  
      def AddToVector(self, offset, v):
          r"""AddToVector(DenseMatrix self, int offset, Vector v)"""
          return _densemat.DenseMatrix_AddToVector(self, offset, v)
      AddToVector = _swig_new_instance_method(_densemat.DenseMatrix_AddToVector)
  
      def GetFromVector(self, offset, v):
          r"""GetFromVector(DenseMatrix self, int offset, Vector v)"""
          return _densemat.DenseMatrix_GetFromVector(self, offset, v)
      GetFromVector = _swig_new_instance_method(_densemat.DenseMatrix_GetFromVector)
  
      def AdjustDofDirection(self, dofs):
          r"""AdjustDofDirection(DenseMatrix self, intArray dofs)"""
          return _densemat.DenseMatrix_AdjustDofDirection(self, dofs)
      AdjustDofDirection = _swig_new_instance_method(_densemat.DenseMatrix_AdjustDofDirection)
  
      def Threshold(self, eps):
          r"""Threshold(DenseMatrix self, double eps)"""
          return _densemat.DenseMatrix_Threshold(self, eps)
      Threshold = _swig_new_instance_method(_densemat.DenseMatrix_Threshold)
  
      def CheckFinite(self):
          r"""CheckFinite(DenseMatrix self) -> int"""
          return _densemat.DenseMatrix_CheckFinite(self)
      CheckFinite = _swig_new_instance_method(_densemat.DenseMatrix_CheckFinite)
  
      def TestInversion(self):
          r"""TestInversion(DenseMatrix self)"""
          return _densemat.DenseMatrix_TestInversion(self)
      TestInversion = _swig_new_instance_method(_densemat.DenseMatrix_TestInversion)
  
      def MemoryUsage(self):
          r"""MemoryUsage(DenseMatrix self) -> long"""
          return _densemat.DenseMatrix_MemoryUsage(self)
      MemoryUsage = _swig_new_instance_method(_densemat.DenseMatrix_MemoryUsage)
  
      def Read(self, on_dev=True):
          r"""Read(DenseMatrix self, bool on_dev=True) -> double const *"""
          return _densemat.DenseMatrix_Read(self, on_dev)
      Read = _swig_new_instance_method(_densemat.DenseMatrix_Read)
  
      def HostRead(self):
          r"""HostRead(DenseMatrix self) -> double const *"""
          return _densemat.DenseMatrix_HostRead(self)
      HostRead = _swig_new_instance_method(_densemat.DenseMatrix_HostRead)
  
      def Write(self, on_dev=True):
          r"""Write(DenseMatrix self, bool on_dev=True) -> double *"""
          return _densemat.DenseMatrix_Write(self, on_dev)
      Write = _swig_new_instance_method(_densemat.DenseMatrix_Write)
  
      def HostWrite(self):
          r"""HostWrite(DenseMatrix self) -> double *"""
          return _densemat.DenseMatrix_HostWrite(self)
      HostWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostWrite)
  
      def ReadWrite(self, on_dev=True):
          r"""ReadWrite(DenseMatrix self, bool on_dev=True) -> double *"""
          return _densemat.DenseMatrix_ReadWrite(self, on_dev)
      ReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_ReadWrite)
  
      def HostReadWrite(self):
          r"""HostReadWrite(DenseMatrix self) -> double *"""
          return _densemat.DenseMatrix_HostReadWrite(self)
      HostReadWrite = _swig_new_instance_method(_densemat.DenseMatrix_HostReadWrite)
      __swig_destroy__ = _densemat.delete_DenseMatrix
  
      def Assign(self, *args):
          r"""
          Assign(DenseMatrix self, double const v)
          Assign(DenseMatrix self, DenseMatrix m)
          Assign(DenseMatrix self, PyObject * numpymat)
          """
  
          from numpy import ndarray, ascontiguousarray
          keep_link = False
          if len(args) == 1 and isinstance(args[0], ndarray):
                  if args[0].dtype != 'float64':
                      raise ValueError('Must be float64 array:' + str(args[0].dtype) + ' was given')
                  elif args[0].ndim != 2:
                      raise ValueError('Ndim must be two') 
                  elif args[0].shape[1] != _densemat.DenseMatrix_Size(self):
                      raise ValueError('Length does not match')
                  else:
                      args = (ascontiguousarray(args[0]),)
  
  
          val = _densemat.DenseMatrix_Assign(self, *args)
  
          return self
  
  
          return val
  
  
      def __getitem__(self, *args):
          i, j = args[0][0], args[0][1]
          return _densemat.DenseMatrix___getitem__(self, i, j)
  
  
  
      def __setitem__(self, *args):
          i, j, v = args[0][0], args[0][1], args[1]
          return _densemat.DenseMatrix___setitem__(self, i, j, v)
  
  
  
      def GetDataArray(self):
          r"""GetDataArray(DenseMatrix self) -> PyObject *"""
          return _densemat.DenseMatrix_GetDataArray(self)
      GetDataArray = _swig_new_instance_method(_densemat.DenseMatrix_GetDataArray)
  
      def Print(self, *args):
          r"""
          Print(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)
          Print(DenseMatrix self, char const * file, int precision=8)
          """
          return _densemat.DenseMatrix_Print(self, *args)
      Print = _swig_new_instance_method(_densemat.DenseMatrix_Print)
  
      def PrintGZ(self, file, precision=8):
          r"""PrintGZ(DenseMatrix self, char const * file, int precision=8)"""
          return _densemat.DenseMatrix_PrintGZ(self, file, precision)
      PrintGZ = _swig_new_instance_method(_densemat.DenseMatrix_PrintGZ)
  
      def PrintT(self, *args):
          r"""
          PrintT(DenseMatrix self, std::ostream & out=mfem::out, int width_=4)
          PrintT(DenseMatrix self, char const * file, int precision=8)
          """
          return _densemat.DenseMatrix_PrintT(self, *args)
      PrintT = _swig_new_instance_method(_densemat.DenseMatrix_PrintT)
  
      def PrintTGZ(self, file, precision=8):
          r"""PrintTGZ(DenseMatrix self, char const * file, int precision=8)"""
          return _densemat.DenseMatrix_PrintTGZ(self, file, precision)
      PrintTGZ = _swig_new_instance_method(_densemat.DenseMatrix_PrintTGZ)
  
      def PrintMatlab(self, *args):
          r"""
          PrintMatlab(DenseMatrix self, std::ostream & out=mfem::out)
          PrintMatlab(DenseMatrix self, char const * file, int precision=8)
          """
          return _densemat.DenseMatrix_PrintMatlab(self, *args)
      PrintMatlab = _swig_new_instance_method(_densemat.DenseMatrix_PrintMatlab)
  
      def PrintMatlabGZ(self, file, precision=8):
          r"""PrintMatlabGZ(DenseMatrix self, char const * file, int precision=8)"""
          return _densemat.DenseMatrix_PrintMatlabGZ(self, file, precision)
      PrintMatlabGZ = _swig_new_instance_method(_densemat.DenseMatrix_PrintMatlabGZ)
  
  # Register DenseMatrix in _densemat:
  _densemat.DenseMatrix_swigregister(DenseMatrix)
  
  
  def LinearSolve(A, X, TOL=1.e-9):
      r"""LinearSolve(DenseMatrix A, double * X, double TOL=1.e-9) -> bool"""
      return _densemat.LinearSolve(A, X, TOL)
  LinearSolve = _densemat.LinearSolve
  
  def AddMult(b, c, a):
      r"""AddMult(DenseMatrix b, DenseMatrix c, DenseMatrix a)"""
      return _densemat.AddMult(b, c, a)
  AddMult = _densemat.AddMult
  
  def AddMult_a(alpha, b, c, a):
      r"""AddMult_a(double alpha, DenseMatrix b, DenseMatrix c, DenseMatrix a)"""
      return _densemat.AddMult_a(alpha, b, c, a)
  AddMult_a = _densemat.AddMult_a
  
  def CalcAdjugate(a, adja):
      r"""CalcAdjugate(DenseMatrix a, DenseMatrix adja)"""
      return _densemat.CalcAdjugate(a, adja)
  CalcAdjugate = _densemat.CalcAdjugate
  
  def CalcAdjugateTranspose(a, adjat):
      r"""CalcAdjugateTranspose(DenseMatrix a, DenseMatrix adjat)"""
      return _densemat.CalcAdjugateTranspose(a, adjat)
  CalcAdjugateTranspose = _densemat.CalcAdjugateTranspose
  
  def CalcInverse(a, inva):
      r"""CalcInverse(DenseMatrix a, DenseMatrix inva)"""
      return _densemat.CalcInverse(a, inva)
  CalcInverse = _densemat.CalcInverse
  
  def CalcInverseTranspose(a, inva):
      r"""CalcInverseTranspose(DenseMatrix a, DenseMatrix inva)"""
      return _densemat.CalcInverseTranspose(a, inva)
  CalcInverseTranspose = _densemat.CalcInverseTranspose
  
  def CalcOrtho(J, n):
      r"""CalcOrtho(DenseMatrix J, Vector n)"""
      return _densemat.CalcOrtho(J, n)
  CalcOrtho = _densemat.CalcOrtho
  
  def MultAAt(a, aat):
      r"""MultAAt(DenseMatrix a, DenseMatrix aat)"""
      return _densemat.MultAAt(a, aat)
  MultAAt = _densemat.MultAAt
  
  def MultADAt(A, D, ADAt):
      r"""MultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"""
      return _densemat.MultADAt(A, D, ADAt)
  MultADAt = _densemat.MultADAt
  
  def AddMultADAt(A, D, ADAt):
      r"""AddMultADAt(DenseMatrix A, Vector D, DenseMatrix ADAt)"""
      return _densemat.AddMultADAt(A, D, ADAt)
  AddMultADAt = _densemat.AddMultADAt
  
  def MultABt(A, B, ABt):
      r"""MultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"""
      return _densemat.MultABt(A, B, ABt)
  MultABt = _densemat.MultABt
  
  def MultADBt(A, D, B, ADBt):
      r"""MultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"""
      return _densemat.MultADBt(A, D, B, ADBt)
  MultADBt = _densemat.MultADBt
  
  def AddMultABt(A, B, ABt):
      r"""AddMultABt(DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"""
      return _densemat.AddMultABt(A, B, ABt)
  AddMultABt = _densemat.AddMultABt
  
  def AddMultADBt(A, D, B, ADBt):
      r"""AddMultADBt(DenseMatrix A, Vector D, DenseMatrix B, DenseMatrix ADBt)"""
      return _densemat.AddMultADBt(A, D, B, ADBt)
  AddMultADBt = _densemat.AddMultADBt
  
  def AddMult_a_ABt(a, A, B, ABt):
      r"""AddMult_a_ABt(double a, DenseMatrix A, DenseMatrix B, DenseMatrix ABt)"""
      return _densemat.AddMult_a_ABt(a, A, B, ABt)
  AddMult_a_ABt = _densemat.AddMult_a_ABt
  
  def MultAtB(A, B, AtB):
      r"""MultAtB(DenseMatrix A, DenseMatrix B, DenseMatrix AtB)"""
      return _densemat.MultAtB(A, B, AtB)
  MultAtB = _densemat.MultAtB
  
  def AddMult_a_AAt(a, A, AAt):
      r"""AddMult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"""
      return _densemat.AddMult_a_AAt(a, A, AAt)
  AddMult_a_AAt = _densemat.AddMult_a_AAt
  
  def Mult_a_AAt(a, A, AAt):
      r"""Mult_a_AAt(double a, DenseMatrix A, DenseMatrix AAt)"""
      return _densemat.Mult_a_AAt(a, A, AAt)
  Mult_a_AAt = _densemat.Mult_a_AAt
  
  def MultVVt(v, vvt):
      r"""MultVVt(Vector v, DenseMatrix vvt)"""
      return _densemat.MultVVt(v, vvt)
  MultVVt = _densemat.MultVVt
  
  def MultVWt(v, w, VWt):
      r"""MultVWt(Vector v, Vector w, DenseMatrix VWt)"""
      return _densemat.MultVWt(v, w, VWt)
  MultVWt = _densemat.MultVWt
  
  def AddMultVWt(v, w, VWt):
      r"""AddMultVWt(Vector v, Vector w, DenseMatrix VWt)"""
      return _densemat.AddMultVWt(v, w, VWt)
  AddMultVWt = _densemat.AddMultVWt
  
  def AddMultVVt(v, VWt):
      r"""AddMultVVt(Vector v, DenseMatrix VWt)"""
      return _densemat.AddMultVVt(v, VWt)
  AddMultVVt = _densemat.AddMultVVt
  
  def AddMult_a_VWt(a, v, w, VWt):
      r"""AddMult_a_VWt(double const a, Vector v, Vector w, DenseMatrix VWt)"""
      return _densemat.AddMult_a_VWt(a, v, w, VWt)
  AddMult_a_VWt = _densemat.AddMult_a_VWt
  
  def AddMult_a_VVt(a, v, VVt):
      r"""AddMult_a_VVt(double const a, Vector v, DenseMatrix VVt)"""
      return _densemat.AddMult_a_VVt(a, v, VVt)
  AddMult_a_VVt = _densemat.AddMult_a_VVt
  class LUFactors(object):
      r"""Proxy of C++ mfem::LUFactors class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
      data = property(_densemat.LUFactors_data_get, _densemat.LUFactors_data_set, doc=r"""data : p.double""")
      ipiv = property(_densemat.LUFactors_ipiv_get, _densemat.LUFactors_ipiv_set, doc=r"""ipiv : p.int""")
      ipiv_base = _densemat.LUFactors_ipiv_base
      
  
      def __init__(self, *args):
          r"""
          __init__(LUFactors self) -> LUFactors
          __init__(LUFactors self, double * data_, int * ipiv_) -> LUFactors
          """
          _densemat.LUFactors_swiginit(self, _densemat.new_LUFactors(*args))
  
      def Factor(self, m, TOL=0.0):
          r"""Factor(LUFactors self, int m, double TOL=0.0) -> bool"""
          return _densemat.LUFactors_Factor(self, m, TOL)
      Factor = _swig_new_instance_method(_densemat.LUFactors_Factor)
  
      def Det(self, m):
          r"""Det(LUFactors self, int m) -> double"""
          return _densemat.LUFactors_Det(self, m)
      Det = _swig_new_instance_method(_densemat.LUFactors_Det)
  
      def Mult(self, m, n, X):
          r"""Mult(LUFactors self, int m, int n, double * X)"""
          return _densemat.LUFactors_Mult(self, m, n, X)
      Mult = _swig_new_instance_method(_densemat.LUFactors_Mult)
  
      def LSolve(self, m, n, X):
          r"""LSolve(LUFactors self, int m, int n, double * X)"""
          return _densemat.LUFactors_LSolve(self, m, n, X)
      LSolve = _swig_new_instance_method(_densemat.LUFactors_LSolve)
  
      def USolve(self, m, n, X):
          r"""USolve(LUFactors self, int m, int n, double * X)"""
          return _densemat.LUFactors_USolve(self, m, n, X)
      USolve = _swig_new_instance_method(_densemat.LUFactors_USolve)
  
      def Solve(self, m, n, X):
          r"""Solve(LUFactors self, int m, int n, double * X)"""
          return _densemat.LUFactors_Solve(self, m, n, X)
      Solve = _swig_new_instance_method(_densemat.LUFactors_Solve)
  
      def RightSolve(self, m, n, X):
          r"""RightSolve(LUFactors self, int m, int n, double * X)"""
          return _densemat.LUFactors_RightSolve(self, m, n, X)
      RightSolve = _swig_new_instance_method(_densemat.LUFactors_RightSolve)
  
      def GetInverseMatrix(self, m, X):
          r"""GetInverseMatrix(LUFactors self, int m, double * X)"""
          return _densemat.LUFactors_GetInverseMatrix(self, m, X)
      GetInverseMatrix = _swig_new_instance_method(_densemat.LUFactors_GetInverseMatrix)
  
      @staticmethod
      def SubMult(m, n, r, A21, X1, X2):
          r"""SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"""
          return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2)
      SubMult = _swig_new_static_method(_densemat.LUFactors_SubMult)
  
      def BlockFactor(self, m, n, A12, A21, A22):
          r"""BlockFactor(LUFactors self, int m, int n, double * A12, double * A21, double * A22)"""
          return _densemat.LUFactors_BlockFactor(self, m, n, A12, A21, A22)
      BlockFactor = _swig_new_instance_method(_densemat.LUFactors_BlockFactor)
  
      def BlockForwSolve(self, m, n, r, L21, B1, B2):
          r"""BlockForwSolve(LUFactors self, int m, int n, int r, double const * L21, double * B1, double * B2)"""
          return _densemat.LUFactors_BlockForwSolve(self, m, n, r, L21, B1, B2)
      BlockForwSolve = _swig_new_instance_method(_densemat.LUFactors_BlockForwSolve)
  
      def BlockBackSolve(self, m, n, r, U12, X2, Y1):
          r"""BlockBackSolve(LUFactors self, int m, int n, int r, double const * U12, double const * X2, double * Y1)"""
          return _densemat.LUFactors_BlockBackSolve(self, m, n, r, U12, X2, Y1)
      BlockBackSolve = _swig_new_instance_method(_densemat.LUFactors_BlockBackSolve)
      __swig_destroy__ = _densemat.delete_LUFactors
  
  # Register LUFactors in _densemat:
  _densemat.LUFactors_swigregister(LUFactors)
  
  def LUFactors_SubMult(m, n, r, A21, X1, X2):
      r"""LUFactors_SubMult(int m, int n, int r, double const * A21, double const * X1, double * X2)"""
      return _densemat.LUFactors_SubMult(m, n, r, A21, X1, X2)
  LUFactors_SubMult = _densemat.LUFactors_SubMult
  
  class DenseMatrixInverse(mfem._ser.matrix.MatrixInverse):
      r"""Proxy of C++ mfem::DenseMatrixInverse class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(DenseMatrixInverse self) -> DenseMatrixInverse
          __init__(DenseMatrixInverse self, DenseMatrix mat) -> DenseMatrixInverse
          __init__(DenseMatrixInverse self, DenseMatrix mat) -> DenseMatrixInverse
          """
          _densemat.DenseMatrixInverse_swiginit(self, _densemat.new_DenseMatrixInverse(*args))
  
      def Size(self):
          r"""Size(DenseMatrixInverse self) -> int"""
          return _densemat.DenseMatrixInverse_Size(self)
      Size = _swig_new_instance_method(_densemat.DenseMatrixInverse_Size)
  
      def Factor(self, *args):
          r"""
          Factor(DenseMatrixInverse self)
          Factor(DenseMatrixInverse self, DenseMatrix mat)
          """
          return _densemat.DenseMatrixInverse_Factor(self, *args)
      Factor = _swig_new_instance_method(_densemat.DenseMatrixInverse_Factor)
  
      def SetOperator(self, op):
          r"""SetOperator(DenseMatrixInverse self, Operator op)"""
          return _densemat.DenseMatrixInverse_SetOperator(self, op)
      SetOperator = _swig_new_instance_method(_densemat.DenseMatrixInverse_SetOperator)
  
      def Mult(self, *args):
          r"""
          Mult(DenseMatrixInverse self, double const * x, double * y)
          Mult(DenseMatrixInverse self, Vector x, Vector y)
          Mult(DenseMatrixInverse self, DenseMatrix B, DenseMatrix X)
          Mult(DenseMatrixInverse self, DenseMatrix X)
          """
          return _densemat.DenseMatrixInverse_Mult(self, *args)
      Mult = _swig_new_instance_method(_densemat.DenseMatrixInverse_Mult)
  
      def GetInverseMatrix(self, Ainv):
          r"""GetInverseMatrix(DenseMatrixInverse self, DenseMatrix Ainv)"""
          return _densemat.DenseMatrixInverse_GetInverseMatrix(self, Ainv)
      GetInverseMatrix = _swig_new_instance_method(_densemat.DenseMatrixInverse_GetInverseMatrix)
  
      def Det(self):
          r"""Det(DenseMatrixInverse self) -> double"""
          return _densemat.DenseMatrixInverse_Det(self)
      Det = _swig_new_instance_method(_densemat.DenseMatrixInverse_Det)
  
      def TestInversion(self):
          r"""TestInversion(DenseMatrixInverse self)"""
          return _densemat.DenseMatrixInverse_TestInversion(self)
      TestInversion = _swig_new_instance_method(_densemat.DenseMatrixInverse_TestInversion)
      __swig_destroy__ = _densemat.delete_DenseMatrixInverse
  
  # Register DenseMatrixInverse in _densemat:
  _densemat.DenseMatrixInverse_swigregister(DenseMatrixInverse)
  
  class DenseMatrixEigensystem(object):
      r"""Proxy of C++ mfem::DenseMatrixEigensystem class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(DenseMatrixEigensystem self, DenseMatrix m) -> DenseMatrixEigensystem
          __init__(DenseMatrixEigensystem self, DenseMatrixEigensystem other) -> DenseMatrixEigensystem
          """
          _densemat.DenseMatrixEigensystem_swiginit(self, _densemat.new_DenseMatrixEigensystem(*args))
  
      def Eval(self):
          r"""Eval(DenseMatrixEigensystem self)"""
          return _densemat.DenseMatrixEigensystem_Eval(self)
      Eval = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eval)
  
      def Eigenvalues(self):
          r"""Eigenvalues(DenseMatrixEigensystem self) -> Vector"""
          return _densemat.DenseMatrixEigensystem_Eigenvalues(self)
      Eigenvalues = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalues)
  
      def Eigenvectors(self):
          r"""Eigenvectors(DenseMatrixEigensystem self) -> DenseMatrix"""
          return _densemat.DenseMatrixEigensystem_Eigenvectors(self)
      Eigenvectors = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvectors)
  
      def Eigenvalue(self, i):
          r"""Eigenvalue(DenseMatrixEigensystem self, int i) -> double"""
          return _densemat.DenseMatrixEigensystem_Eigenvalue(self, i)
      Eigenvalue = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvalue)
  
      def Eigenvector(self, i):
          r"""Eigenvector(DenseMatrixEigensystem self, int i) -> Vector"""
          return _densemat.DenseMatrixEigensystem_Eigenvector(self, i)
      Eigenvector = _swig_new_instance_method(_densemat.DenseMatrixEigensystem_Eigenvector)
      __swig_destroy__ = _densemat.delete_DenseMatrixEigensystem
  
  # Register DenseMatrixEigensystem in _densemat:
  _densemat.DenseMatrixEigensystem_swigregister(DenseMatrixEigensystem)
  
  class DenseMatrixSVD(object):
      r"""Proxy of C++ mfem::DenseMatrixSVD class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(DenseMatrixSVD self, DenseMatrix M) -> DenseMatrixSVD
          __init__(DenseMatrixSVD self, int h, int w) -> DenseMatrixSVD
          """
          _densemat.DenseMatrixSVD_swiginit(self, _densemat.new_DenseMatrixSVD(*args))
  
      def Eval(self, M):
          r"""Eval(DenseMatrixSVD self, DenseMatrix M)"""
          return _densemat.DenseMatrixSVD_Eval(self, M)
      Eval = _swig_new_instance_method(_densemat.DenseMatrixSVD_Eval)
  
      def Singularvalues(self):
          r"""Singularvalues(DenseMatrixSVD self) -> Vector"""
          return _densemat.DenseMatrixSVD_Singularvalues(self)
      Singularvalues = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalues)
  
      def Singularvalue(self, i):
          r"""Singularvalue(DenseMatrixSVD self, int i) -> double"""
          return _densemat.DenseMatrixSVD_Singularvalue(self, i)
      Singularvalue = _swig_new_instance_method(_densemat.DenseMatrixSVD_Singularvalue)
      __swig_destroy__ = _densemat.delete_DenseMatrixSVD
  
  # Register DenseMatrixSVD in _densemat:
  _densemat.DenseMatrixSVD_swigregister(DenseMatrixSVD)
  
  class DenseTensor(object):
      r"""Proxy of C++ mfem::DenseTensor class."""
  
      thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
      __repr__ = _swig_repr
  
      def __init__(self, *args):
          r"""
          __init__(DenseTensor self) -> DenseTensor
          __init__(DenseTensor self, int i, int j, int k) -> DenseTensor
          __init__(DenseTensor self, DenseTensor other) -> DenseTensor
          """
          _densemat.DenseTensor_swiginit(self, _densemat.new_DenseTensor(*args))
  
      def SizeI(self):
          r"""SizeI(DenseTensor self) -> int"""
          return _densemat.DenseTensor_SizeI(self)
      SizeI = _swig_new_instance_method(_densemat.DenseTensor_SizeI)
  
      def SizeJ(self):
          r"""SizeJ(DenseTensor self) -> int"""
          return _densemat.DenseTensor_SizeJ(self)
      SizeJ = _swig_new_instance_method(_densemat.DenseTensor_SizeJ)
  
      def SizeK(self):
          r"""SizeK(DenseTensor self) -> int"""
          return _densemat.DenseTensor_SizeK(self)
      SizeK = _swig_new_instance_method(_densemat.DenseTensor_SizeK)
  
      def TotalSize(self):
          r"""TotalSize(DenseTensor self) -> int"""
          return _densemat.DenseTensor_TotalSize(self)
      TotalSize = _swig_new_instance_method(_densemat.DenseTensor_TotalSize)
  
      def SetSize(self, i, j, k):
          r"""SetSize(DenseTensor self, int i, int j, int k)"""
          return _densemat.DenseTensor_SetSize(self, i, j, k)
      SetSize = _swig_new_instance_method(_densemat.DenseTensor_SetSize)
  
      def UseExternalData(self, ext_data, i, j, k):
          r"""UseExternalData(DenseTensor self, double * ext_data, int i, int j, int k)"""
          return _densemat.DenseTensor_UseExternalData(self, ext_data, i, j, k)
      UseExternalData = _swig_new_instance_method(_densemat.DenseTensor_UseExternalData)
  
      def __call__(self, *args):
          r"""
          __call__(DenseTensor self, int k) -> DenseMatrix
          __call__(DenseTensor self, int k) -> DenseMatrix
          __call__(DenseTensor self, int i, int j, int k) -> double
          __call__(DenseTensor self, int i, int j, int k) -> double const &
          """
          return _densemat.DenseTensor___call__(self, *args)
      __call__ = _swig_new_instance_method(_densemat.DenseTensor___call__)
  
      def GetData(self, k):
          r"""GetData(DenseTensor self, int k) -> double *"""
          return _densemat.DenseTensor_GetData(self, k)
      GetData = _swig_new_instance_method(_densemat.DenseTensor_GetData)
  
      def Data(self, *args):
          r"""
          Data(DenseTensor self) -> double
          Data(DenseTensor self) -> double const *
          """
          return _densemat.DenseTensor_Data(self, *args)
      Data = _swig_new_instance_method(_densemat.DenseTensor_Data)
  
      def GetMemory(self, *args):
          r"""
          GetMemory(DenseTensor self) -> mfem::Memory< double >
          GetMemory(DenseTensor self) -> mfem::Memory< double > const &
          """
          return _densemat.DenseTensor_GetMemory(self, *args)
      GetMemory = _swig_new_instance_method(_densemat.DenseTensor_GetMemory)
  
      def AddMult(self, elem_dof, x, y):
          r"""AddMult(DenseTensor self, mfem::Table const & elem_dof, Vector x, Vector y)"""
          return _densemat.DenseTensor_AddMult(self, elem_dof, x, y)
      AddMult = _swig_new_instance_method(_densemat.DenseTensor_AddMult)
  
      def Clear(self):
          r"""Clear(DenseTensor self)"""
          return _densemat.DenseTensor_Clear(self)
      Clear = _swig_new_instance_method(_densemat.DenseTensor_Clear)
  
      def MemoryUsage(self):
          r"""MemoryUsage(DenseTensor self) -> long"""
          return _densemat.DenseTensor_MemoryUsage(self)
      MemoryUsage = _swig_new_instance_method(_densemat.DenseTensor_MemoryUsage)
  
      def Read(self, on_dev=True):
          r"""Read(DenseTensor self, bool on_dev=True) -> double const *"""
          return _densemat.DenseTensor_Read(self, on_dev)
      Read = _swig_new_instance_method(_densemat.DenseTensor_Read)
  
      def HostRead(self):
          r"""HostRead(DenseTensor self) -> double const *"""
          return _densemat.DenseTensor_HostRead(self)
      HostRead = _swig_new_instance_method(_densemat.DenseTensor_HostRead)
  
      def Write(self, on_dev=True):
          r"""Write(DenseTensor self, bool on_dev=True) -> double *"""
          return _densemat.DenseTensor_Write(self, on_dev)
      Write = _swig_new_instance_method(_densemat.DenseTensor_Write)
  
      def HostWrite(self):
          r"""HostWrite(DenseTensor self) -> double *"""
          return _densemat.DenseTensor_HostWrite(self)
      HostWrite = _swig_new_instance_method(_densemat.DenseTensor_HostWrite)
  
      def ReadWrite(self, on_dev=True):
          r"""ReadWrite(DenseTensor self, bool on_dev=True) -> double *"""
          return _densemat.DenseTensor_ReadWrite(self, on_dev)
      ReadWrite = _swig_new_instance_method(_densemat.DenseTensor_ReadWrite)
  
      def HostReadWrite(self):
          r"""HostReadWrite(DenseTensor self) -> double *"""
          return _densemat.DenseTensor_HostReadWrite(self)
      HostReadWrite = _swig_new_instance_method(_densemat.DenseTensor_HostReadWrite)
      __swig_destroy__ = _densemat.delete_DenseTensor
  
      def Assign(self, c):
          r"""Assign(DenseTensor self, double const c)"""
          val = _densemat.DenseTensor_Assign(self, c)
  
          return self
  
  
          return val
  
  
      def __getitem__(self, *args):
        try:
           check = len(args[0]) == 3
        except:
           check = False
        if check:
           i, j, k = args[0][0], args[0][1], args[0][2]
           return _densemat.DenseTensor___getitem__(self, i, j, k)
        try:
           check = int(args[0])
        except:
           check = -1
        if check >= 0:     
           return _densemat.DenseTensor___getitem__(self, check)
  
  
  
      def __setitem__(self, *args):
          i, j, k, v = args[0][0], args[0][1], args[0][2], args[1]
          return _densemat.DenseTensor___setitem__(self, i, j, k, v)
  
  
  
      def GetDataArray(self):
          r"""GetDataArray(DenseTensor self) -> PyObject *"""
          return _densemat.DenseTensor_GetDataArray(self)
      GetDataArray = _swig_new_instance_method(_densemat.DenseTensor_GetDataArray)
  
  # Register DenseTensor in _densemat:
  _densemat.DenseTensor_swigregister(DenseTensor)
  
  
  def BatchLUFactor(Mlu, P, TOL=0.0):
      r"""BatchLUFactor(DenseTensor Mlu, intArray P, double const TOL=0.0)"""
      return _densemat.BatchLUFactor(Mlu, P, TOL)
  BatchLUFactor = _densemat.BatchLUFactor
  
  def BatchLUSolve(Mlu, P, X):
      r"""BatchLUSolve(DenseTensor Mlu, intArray P, Vector X)"""
      return _densemat.BatchLUSolve(Mlu, P, X)
  BatchLUSolve = _densemat.BatchLUSolve
  
  
  