Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Nektar Namespace Reference

< More...

Namespaces

 detail
 
 GlobalMapping
 
 LibUtilities
 
 LocalRegions
 
 MultiRegions
 
 NekConstants
 
 NekMeshUtils
 
 NekOptimize
 
 SolverUtils
 
 SpatialDomains
 
 StdRegions
 The namespace associated with the the StdRegions library (StdRegions introduction)
 
 Thread
 
 Utilities
 

Classes

class  AdjointAdvection
 Advection for the adjoint form of the linearised Navier-Stokes equations. More...
 
class  AlternateSkewAdvection
 
class  APE
 
class  APESolver
 
singleton  Array
 
class  Array< OneD, const DataType >
 1D Array of constant elements with garbage collection and bounds checking. More...
 
class  Array< OneD, DataType >
 1D Array More...
 
class  Array< ThreeD, const DataType >
 3D array with garbage collection and bounds checking. More...
 
class  Array< ThreeD, DataType >
 A 3D array. More...
 
class  Array< TwoD, const DataType >
 2D array with garbage collection and bounds checking. More...
 
class  Array< TwoD, DataType >
 A 2D array. More...
 
singleton  ArrayDestructionPolicy
 
class  ArrayDestructionPolicy< ObjectType, typename boost::disable_if< boost::is_fundamental< ObjectType > >::type >
 
class  ArrayDestructionPolicy< ObjectType, typename boost::enable_if< boost::is_fundamental< ObjectType > >::type >
 
singleton  ArrayInitializationPolicy
 
class  ArrayInitializationPolicy< ObjectType, typename boost::disable_if< boost::is_fundamental< ObjectType > >::type >
 
class  ArrayInitializationPolicy< ObjectType, typename boost::enable_if< boost::is_fundamental< ObjectType > >::type >
 
class  ArterialPressureArea
 A global linear system. More...
 
class  AssignableConcept
 
class  AUSM0Solver
 
class  AUSM1Solver
 
class  AUSM2Solver
 
class  AUSM3Solver
 
class  AverageSolver
 
struct  BandedMatrixFuncs
 
class  Bidomain
 A model for cardiac conduction. More...
 
class  BidomainRoth
 A model for cardiac conduction. More...
 
struct  CanGetRawPtr
 
struct  CanGetRawPtr< NekMatrix< NekMatrix< T, R >, ScaledMatrixTag > >
 
struct  CanGetRawPtr< NekMatrix< T, M > >
 
struct  CanGetRawPtr< NekMatrix< T, StandardMatrixTag > >
 
class  CellModel
 Cell model base class. More...
 
class  CellModelAlievPanfilov
 Aliev Panfilov model. More...
 
class  CellModelFitzHughNagumo
 FitzHugh-Nagumo model. More...
 
class  CFLtester
 
class  CompressibleFlowSystem
 
class  CompressibleSolver
 
struct  ConsistentObjectAccess
 
struct  ConsistentObjectAccess< boost::shared_ptr< DataType > >
 
struct  ConsistentObjectAccess< DataType * >
 
singleton  ConstMatrix
 
class  CoupledAssemblyMap
 Modified version of MultiRegions::AssemblyMapCG that allows for coupled fields [u,v,w] instead of individual scalar fields u, v and w. More...
 
class  CoupledLinearNS
 
class  CoupledLocalToGlobalC0ContMap
 
struct  coupledSolverMatrices
 
class  CourtemancheRamirezNattel98
 
struct  DiagonalMatrixFuncs
 
class  EigenValuesAdvection
 
class  EulerADCFE
 
class  EulerCFE
 
class  ExactSolverToro
 
class  Extrapolate
 
class  FentonKarma
 
class  FilterBenchmark
 Records activation and repolarisation times. More...
 
class  FilterCellHistoryPoints
 
class  FilterCheckpointCellModel
 
class  FilterElectrogram
 
class  FilterEnergy
 
class  FilterMovingBody
 
class  FlagList
 Defines a list of flags. More...
 
class  ForcingMovingBody
 
class  ForcingStabilityCoupledLNS
 
struct  FourD
 
class  Fox02
 
struct  FullMatrixFuncs
 
struct  HBCInfo
 
class  Helmholtz
 
class  HLLCSolver
 
class  HLLSolver
 
class  ImageWarpingSystem
 
class  IncNavierStokes
 This class is the base class for Navier Stokes problems. More...
 
struct  InterfacePoint
 
struct  IsSharedPointer
 
struct  IsSharedPointer< boost::shared_ptr< DataType > >
 
struct  IsVector
 
struct  IsVector< NekVector< DataType > >
 
class  IterativeElasticSystem
 Class for iterative elastic system, in which linear elasticity is applied in substeps to attain a large deformation. More...
 
class  Laplace
 
class  LaxFriedrichsSolver
 
class  LinearAverageSolver
 
class  LinearElasticSystem
 Base class for linear elastic system. More...
 
class  LinearHLLSolver
 
class  LinearisedAdvection
 
class  LinearSWE
 
class  LinearSWESolver
 
class  LinearSystem
 
struct  LinearSystemSolver
 
struct  LowerTriangularBandedMatrixFuncs
 
struct  LowerTriangularMatrixFuncs
 
class  LuoRudy91
 
class  LymphaticPressureArea
 A global linear system. More...
 
class  MappingExtrapolate
 
singleton  Matrix
 
class  MemoryManager
 General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...
 
class  MemPool
 
class  Monodomain
 A model for cardiac conduction. More...
 
class  NavierStokesAdvection
 
class  NavierStokesCFE
 
singleton  NekMatrix
 
class  NekMatrix< DataType, StandardMatrixTag >
 Standard Matrix. More...
 
class  NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >
 
class  NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >
 
class  NekPoint
 
class  NekPtr
 
singleton  NekSparseDiagBlkMatrix
 
singleton  NekSparseMatrix
 
singleton  NekVector
 
class  NoAdvection
 
class  NonlinearPeregrine
 
class  NonlinearSWE
 
class  NonlinearSWESolver
 
class  NoSolver
 
struct  OneD
 
class  PanditGilesDemir03
 
class  ParseUtils
 
class  Poisson
 
class  Protocol
 Protocol base class. More...
 
class  ProtocolS1
 Protocol base class. More...
 
class  ProtocolS1S2
 Protocol base class. More...
 
class  ProtocolSingle
 Protocol base class. More...
 
class  PulseWaveBoundary
 
class  PulseWavePressureArea
 
class  PulseWavePropagation
 
class  PulseWaveSystem
 Base class for unsteady solvers. More...
 
class  PulseWaveSystemOutput
 Base class for unsteady solvers. More...
 
class  QInflow
 A global linear system. More...
 
struct  RawType
 
struct  RawType< boost::shared_ptr< const T > >
 
struct  RawType< boost::shared_ptr< const volatile T > >
 
struct  RawType< boost::shared_ptr< T > >
 
struct  RawType< boost::shared_ptr< volatile T > >
 
struct  RawType< const boost::shared_ptr< const T > >
 
struct  RawType< const boost::shared_ptr< const volatile T > >
 
struct  RawType< const boost::shared_ptr< T > >
 
struct  RawType< const boost::shared_ptr< volatile T > >
 
struct  RawType< const T * >
 
struct  RawType< const T *const >
 
struct  RawType< const T *const volatile >
 
struct  RawType< const T *volatile >
 
struct  RawType< const T >
 
struct  RawType< const volatile boost::shared_ptr< const T > >
 
struct  RawType< const volatile boost::shared_ptr< const volatile T > >
 
struct  RawType< const volatile boost::shared_ptr< T > >
 
struct  RawType< const volatile boost::shared_ptr< volatile T > >
 
struct  RawType< const volatile T * >
 
struct  RawType< const volatile T *const >
 
struct  RawType< const volatile T *const volatile >
 
struct  RawType< const volatile T *volatile >
 
struct  RawType< const volatile T >
 
struct  RawType< T * >
 
struct  RawType< T *const >
 
struct  RawType< T *const volatile >
 
struct  RawType< T *volatile >
 
struct  RawType< volatile boost::shared_ptr< const T > >
 
struct  RawType< volatile boost::shared_ptr< const volatile T > >
 
struct  RawType< volatile boost::shared_ptr< T > >
 
struct  RawType< volatile boost::shared_ptr< volatile T > >
 
struct  RawType< volatile T * >
 
struct  RawType< volatile T *const >
 
struct  RawType< volatile T *const volatile >
 
struct  RawType< volatile T *volatile >
 
struct  RawType< volatile T >
 
class  RCROutflow
 A global linear system. More...
 
class  RoeSolver
 
class  ROutflow
 A global linear system. More...
 
class  ShallowWaterSystem
 Base class for unsteady solvers. More...
 
class  SkewSymmetricAdvection
 
class  StandardExtrapolate
 
class  SteadyAdvectionDiffusion
 
class  SteadyAdvectionDiffusionReaction
 
class  Stimulus
 Stimulus base class. More...
 
class  StimulusCirc
 Protocol base class. More...
 
class  StimulusPoint
 Protocol base class. More...
 
class  StimulusRect
 Protocol base class. More...
 
class  StorageSmvBsr
 
class  SubSteppingExtrapolate
 
struct  SymmetricBandedMatrixFuncs
 
struct  SymmetricMatrixFuncs
 
class  TenTusscher06
 
class  TerminalOutflow
 A global linear system. More...
 
struct  ThreeD
 
class  TimeDependentInflow
 A global linear system. More...
 
class  Timer
 
struct  TriangularBandedMatrixFuncs
 
struct  TriangularMatrixFuncs
 
struct  TwoD
 
class  UndefinedInOutflow
 A global linear system. More...
 
class  UnsteadyAdvection
 
class  UnsteadyAdvectionDiffusion
 
class  UnsteadyDiffusion
 
class  UnsteadyInviscidBurger
 
class  UnsteadyViscousBurgers
 
struct  UpperTriangularBandedMatrixFuncs
 
struct  UpperTriangularMatrixFuncs
 
class  UpwindSolver
 
class  VCSMapping
 
class  VelocityCorrectionScheme
 
class  VortexWaveInteraction
 
class  Winslow99
 
class  XmlUtil
 

Typedefs

typedef double NekDouble
 
typedef boost::int32_t NekInt
 
typedef boost::int32_t NekInt32
 
typedef boost::int64_t NekInt64
 
typedef boost::shared_ptr
< NekMatrix< NekDouble,
StandardMatrixTag > > 
SharedNekMatrixPtr
 
typedef NekMatrix< NekMatrix
< NekDouble, StandardMatrixTag >
, ScaledMatrixTag > 
DNekScalMat
 
typedef boost::shared_ptr
< DNekScalMat
DNekScalMatSharedPtr
 
typedef NekVector< NekDoubleDNekVec
 
typedef NekMatrix< NekDouble,
StandardMatrixTag > 
DNekMat
 
typedef NekMatrix< NekDouble,
StandardMatrixTag > 
DenseMatrix
 
typedef NekMatrix< DenseMatrix,
ScaledMatrixTag > 
ScaledMatrix
 
typedef NekMatrix< NekMatrix
< NekDouble, StandardMatrixTag >
, BlockMatrixTag > 
DNekBlkMat
 
typedef NekMatrix< DenseMatrix,
BlockMatrixTag > 
BlockMatrix
 
typedef NekMatrix< NekMatrix
< NekMatrix< NekDouble,
StandardMatrixTag >
, BlockMatrixTag >
, BlockMatrixTag > 
BlkMatDNekBlkMat
 
typedef NekMatrix< NekMatrix
< NekMatrix< NekDouble,
StandardMatrixTag >
, ScaledMatrixTag >
, BlockMatrixTag > 
DNekScalBlkMat
 
typedef NekMatrix< NekMatrix
< NekMatrix< NekMatrix
< NekDouble, StandardMatrixTag >
, ScaledMatrixTag >
, BlockMatrixTag >
, BlockMatrixTag > 
BlkMatDNekScalBlkMat
 
typedef boost::shared_ptr
< DNekMat
DNekMatSharedPtr
 
typedef boost::shared_ptr
< DNekBlkMat
DNekBlkMatSharedPtr
 
typedef boost::shared_ptr
< BlkMatDNekBlkMat
BlkMatDNekBlkMatSharedPtr
 
typedef boost::shared_ptr
< DNekScalBlkMat
DNekScalBlkMatSharedPtr
 
typedef boost::shared_ptr
< BlkMatDNekScalBlkMat
BlkMatDNekScalBlkMatSharedPtr
 
typedef LinearSystem DNekLinSys
 
typedef boost::shared_ptr
< DNekLinSys
DNekLinSysSharedPtr
 
typedef LinearSystem DNekScalLinSys
 
typedef boost::shared_ptr
< DNekScalLinSys
DNekScalLinSysSharedPtr
 
typedef unsigned int IndexType
 
typedef Array< OneD, IndexTypeIndexVector
 
typedef std::pair< IndexType,
IndexType
CoordType
 
typedef NekDouble COOEntryType
 
typedef std::map< CoordType,
NekDouble
COOMatType
 
typedef COOMatType::const_iterator COOMatTypeConstIt
 
typedef boost::shared_ptr
< COOMatType
COOMatTypeSharedPtr
 
typedef Array< OneD, COOMatTypeCOOMatVector
 
typedef Array< OneD, NekDoubleBCOEntryType
 
typedef std::map< CoordType,
BCOEntryType
BCOMatType
 
typedef BCOMatType::const_iterator BCOMatTypeConstIt
 
typedef boost::shared_ptr
< BCOMatType
BCOMatTypeSharedPtr
 
typedef Array< OneD, BCOMatTypeBCOMatVector
 
typedef std::vector< std::pair
< std::string, std::string > > 
SummaryList
 
typedef boost::shared_ptr
< CellModel
CellModelSharedPtr
 A shared pointer to an EquationSystem object. More...
 
typedef
LibUtilities::NekFactory
< std::string, CellModel,
const
LibUtilities::SessionReaderSharedPtr
&, const
MultiRegions::ExpListSharedPtr & > 
CellModelFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef boost::shared_ptr
< Protocol
ProtocolSharedPtr
 A shared pointer to an EquationSystem object. More...
 
typedef
LibUtilities::NekFactory
< std::string, Protocol, const
LibUtilities::SessionReaderSharedPtr
&, const TiXmlElement * > 
ProtocolFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef boost::shared_ptr
< Stimulus
StimulusSharedPtr
 A shared pointer to an EquationSystem object. More...
 
typedef
LibUtilities::NekFactory
< std::string, Stimulus, const
LibUtilities::SessionReaderSharedPtr
&, const
MultiRegions::ExpListSharedPtr
&, const TiXmlElement * > 
StimulusFactory
 Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class. More...
 
typedef struct
Nektar::coupledSolverMatrices 
CoupledSolverMatrices
 
typedef boost::shared_ptr
< CoupledLocalToGlobalC0ContMap
CoupledLocalToGlobalC0ContMapSharedPtr
 
typedef boost::shared_ptr
< Extrapolate
ExtrapolateSharedPtr
 
typedef
LibUtilities::NekFactory
< std::string, Extrapolate,
const
LibUtilities::SessionReaderSharedPtr
&, Array< OneD,
MultiRegions::ExpListSharedPtr >
&, MultiRegions::ExpListSharedPtr
&, const Array< OneD, int >
&, const
SolverUtils::AdvectionSharedPtr & > 
ExtrapolateFactory
 
typedef boost::shared_ptr
< IncNavierStokes
IncNavierStokesSharedPtr
 
typedef boost::shared_ptr
< MappingExtrapolate
MappingExtrapolateSharedPtr
 
typedef boost::shared_ptr
< StandardExtrapolate
StandardExtrapolateSharedPtr
 
typedef boost::shared_ptr
< SubSteppingExtrapolate
SubSteppingExtrapolateSharedPtr
 
typedef boost::shared_ptr
< VCSMapping
VCSMappingSharedPtr
 
typedef boost::shared_ptr
< VelocityCorrectionScheme
VelocityCorrectionSchemeSharedPtr
 
typedef boost::shared_ptr
< FilterMovingBody
FilterMovingBodySharedPtr
 
typedef std::map< std::string,
std::string > 
FilterParams
 
typedef std::pair< std::string,
FilterParams
FilterMap
 
typedef boost::shared_ptr
< CoupledAssemblyMap
CoupledAssemblyMapSharedPtr
 
typedef boost::shared_ptr
< ArterialPressureArea
ArterialPressureAreaSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< LymphaticPressureArea
LymphaticPressureAreaSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< PulseWaveBoundary
PulseWaveBoundarySharedPtr
 
typedef
LibUtilities::NekFactory
< std::string,
PulseWaveBoundary, Array< OneD,
MultiRegions::ExpListSharedPtr >
&, const
LibUtilities::SessionReaderSharedPtr
&, PulseWavePressureAreaSharedPtr & > 
BoundaryFactory
 
typedef boost::shared_ptr
< PulseWavePressureArea
PulseWavePressureAreaSharedPtr
 
typedef
LibUtilities::NekFactory
< std::string,
PulseWavePressureArea, Array
< OneD,
MultiRegions::ExpListSharedPtr >
&, const
LibUtilities::SessionReaderSharedPtr & > 
PressureAreaFactory
 
typedef boost::shared_ptr
< InterfacePoint
InterfacePointShPtr
 
typedef boost::shared_ptr
< PulseWaveSystem
PulseWaveSystemSharedPtr
 
typedef boost::shared_ptr
< QInflow
QInflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< RCROutflow
RCROutflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< ROutflow
ROutflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< TerminalOutflow
TerminalOutflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< TimeDependentInflow
TimeDependentInflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< UndefinedInOutflow
UndefinedInOutflowSharedPtr
 Pointer to a PulseWaveOutflow object. More...
 
typedef boost::shared_ptr
< PulseWaveSystemOutput
PulseWaveSystemOutputSharedPtr
 

Enumerations

enum  Direction { xDir = 0, yDir = 1, zDir = 2 }
 
enum  OutputFormat {
  eTecplot, eTecplotZones, eTecplotSingleBlock, eGmsh,
  eGnuplot
}
 
enum  FlagType { eUseGlobal }
 Enumeration of flags for passing a list of options. More...
 
enum  AllowWrappingOfConstArrays { eVECTOR_WRAPPER }
 
enum  MatrixStorage {
  eFULL, eDIAGONAL, eUPPER_TRIANGULAR, eLOWER_TRIANGULAR,
  eSYMMETRIC, ePOSITIVE_DEFINITE_SYMMETRIC, eBANDED, eSYMMETRIC_BANDED,
  ePOSITIVE_DEFINITE_SYMMETRIC_BANDED, eUPPER_TRIANGULAR_BANDED, eLOWER_TRIANGULAR_BANDED
}
 
enum  PointerWrapper { eWrapper, eCopy }
 Specifies if the pointer passed to a NekMatrix or NekVector is copied into an internal representation or used directly. More...
 
enum  ProblemType {
  eGeneral, SIZE_ProblemType, eGeneral, eIsentropicVortex,
  eRinglebFlow, SIZE_ProblemType, eGeneral, SIZE_ProblemType,
  eGeneral, eSolitaryWave, SIZE_ProblemType
}
 
enum  ProblemType {
  eGeneral, SIZE_ProblemType, eGeneral, eIsentropicVortex,
  eRinglebFlow, SIZE_ProblemType, eGeneral, SIZE_ProblemType,
  eGeneral, eSolitaryWave, SIZE_ProblemType
}
 
enum  ProblemType {
  eGeneral, SIZE_ProblemType, eGeneral, eIsentropicVortex,
  eRinglebFlow, SIZE_ProblemType, eGeneral, SIZE_ProblemType,
  eGeneral, eSolitaryWave, SIZE_ProblemType
}
 
enum  EquationType {
  eNoEquationType, eSteadyStokes, eSteadyOseen, eSteadyLinearisedNS,
  eUnsteadyStokes, eUnsteadyLinearisedNS, eUnsteadyNavierStokes, eSteadyNavierStokes,
  eEquationTypeSize
}
 
enum  AdvectionForm {
  eNoAdvectionForm, eConvective, eNonConservative, eLinearised,
  eAdjoint, eSkewSymmetric, eNoAdvection, eAdvectionFormSize
}
 
enum  UpwindTypePulse { eNotSetPulse, eUpwindPulse, SIZE_UpwindTypePulse }
 
enum  ProblemType {
  eGeneral, SIZE_ProblemType, eGeneral, eIsentropicVortex,
  eRinglebFlow, SIZE_ProblemType, eGeneral, SIZE_ProblemType,
  eGeneral, eSolitaryWave, SIZE_ProblemType
}
 
enum  VWIIterationType {
  eFixedAlpha, eFixedWaveForcing, eFixedAlphaWaveForcing, eFixedWaveForcingWithSubIterationOnAlpha,
  eVWIIterationTypeSize
}
 

Functions

bool operator== (const Array< OneD, NekDouble > &lhs, const Array< OneD, NekDouble > &rhs)
 
bool IsEqual (const Array< OneD, const NekDouble > &lhs, const Array< OneD, const NekDouble > &rhs, NekDouble tol)
 
bool operator== (const Array< TwoD, NekDouble > &lhs, const Array< TwoD, NekDouble > &rhs)
 
bool IsEqual (const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
 
template<typename DataType >
void DeleteStorage (DataType *data, unsigned int num)
 
template<typename Dim , typename DataType , typename ExtentListType >
boost::shared_ptr
< boost::multi_array_ref
< DataType, Dim::Value > > 
CreateStorage (const ExtentListType &extent)
 
template<typename DataType >
boost::shared_ptr
< boost::multi_array_ref
< DataType, 1 > > 
CreateStorage (unsigned int d1)
 
template<typename DataType >
boost::shared_ptr
< boost::multi_array_ref
< DataType, 2 > > 
CreateStorage (unsigned int d1, unsigned int d2)
 
template<typename DataType >
boost::shared_ptr
< boost::multi_array_ref
< DataType, 3 > > 
CreateStorage (unsigned int d1, unsigned int d2, unsigned int d3)
 
template<typename DataType >
boost::shared_ptr< DataType > MakePtr (DataType *d)
 
template<typename T1 , typename T2 >
bool operator== (const Array< OneD, T1 > &lhs, const Array< OneD, T2 > &rhs)
 
template<typename T1 , typename T2 >
bool operator!= (const Array< OneD, T1 > &lhs, const Array< OneD, T2 > &rhs)
 
template<typename DataType >
Array< OneD, DataType > operator+ (const Array< OneD, DataType > &lhs, unsigned int offset)
 
template<typename DataType >
Array< OneD, DataType > operator+ (unsigned int offset, const Array< OneD, DataType > &rhs)
 
template<typename ConstDataType , typename DataType >
void CopyArray (const Array< OneD, ConstDataType > &source, Array< OneD, DataType > &dest)
 
template<typename ConstDataType , typename DataType >
void CopyArrayN (const Array< OneD, ConstDataType > &source, Array< OneD, DataType > &dest, unsigned int n)
 
template<typename DataType >
bool operator== (const Array< TwoD, DataType > &lhs, const Array< TwoD, DataType > &rhs)
 
template<typename DataType >
bool operator!= (const Array< TwoD, DataType > &lhs, const Array< TwoD, DataType > &rhs)
 
template<typename InnerMatrixType >
NekMatrix< InnerMatrixType,
BlockMatrixTag > 
Transpose (NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
 
template<typename ResultDataType , typename LhsDataType , typename LhsMatrixType >
void Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const ResultDataType &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(1,(const NekDouble &))) template< typename DataType
 
LhsMatrixType NekMatrix
< typename NekMatrix
< LhsDataType, LhsMatrixType >
::NumberType,
StandardMatrixTag > 
Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const DataType &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(0,()),(1,(const NekDouble &))) template< typename RhsDataType
 
ResultDataType void Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const ResultDataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(2,(DNekMat &, const NekDouble &)),(0,())) template< typename DataType
 
RhsMatrixType NekMatrix
< typename NekMatrix
< RhsDataType, RhsMatrixType >
::NumberType,
StandardMatrixTag > 
Multiply (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(1,(const NekDouble &)),(0,())) template< typename LhsDataType > void MultiplyEqual(NekMatrix< LhsDataType
 
 for (iterator iter=lhs.begin();iter!=lhs.end();++iter)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (MultiplyEqual,(1,(DNekMat &)),(1,(void)),(0,()),(1,(const NekDouble &))) template< typename ResultType
 
RhsMatrixType void NekMultiplyDefaultImpl (NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void NekMultiplyFullMatrixFullMatrix (NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename LhsDataType , typename RhsDataType , typename DataType , typename LhsMatrixType , typename RhsMatrixType >
void Multiply (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Multiply, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) template< typename DataType
 
RhsMatrixType void AddEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void AddEqualNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (AddEqual, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(AddEqualNegatedLhs
 
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat void Add (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void AddNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Add, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(AddNegatedLhs
 
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat NekMatrix< typename
NekMatrix< LhsDataType,
LhsMatrixType >::NumberType,
StandardMatrixTag > 
Add (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Add, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(DNekMat)),(0,()),(0,())) template< typename DataType
 
RhsMatrixType void Subtract (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void SubtractNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (Subtract, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs
 
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
DNekMat void SubtractEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void SubtractEqualNegatedLhs (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (SubtractEqual, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs
 
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat NekMatrix< typename
NekMatrix< LhsDataType,
LhsMatrixType >::NumberType,
StandardMatrixTag > 
Subtract (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekDouble, 0)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekDouble, 0, NekMatrix, 2)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekMatrix, 2, NekVector, 1)
 
 GENERATE_DIVISION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
 
 GENERATE_ADDITION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
 
 GENERATE_SUBTRACTION_OPERATOR (NekMatrix, 2, NekMatrix, 2)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< DataType > Multiply (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void Multiply (NekVector< DataType > &result, const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)
 
template<typename DataType , typename LhsInnerMatrixType >
void Multiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
 
template<typename LhsDataType >
void MultiplyEqual (NekMatrix< LhsDataType, StandardMatrixTag > &lhs, typename boost::call_traits< LhsDataType >::const_reference rhs)
 
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void NekMultiplyFullMatrixFullMatrix (NekMatrix< NekDouble, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::and_< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType > >, CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType > > > >::type *p=0)
 
template<typename RhsInnerType , typename RhsMatrixType >
void MultiplyEqual (NekMatrix< double, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::and_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double >, CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > >::type *t=0)
 
template<typename DataType , typename RhsInnerType , typename RhsMatrixType >
void MultiplyEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename boost::enable_if< boost::mpl::or_< boost::mpl::not_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double > >, boost::mpl::not_< CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > > >::type *t=0)
 
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename
boost::remove_const< typename
NekMatrix< LhsDataType,
LhsMatrixType >::NumberType >
::type, StandardMatrixTag > 
Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void Add (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix
< LhsDataType, LhsMatrixType >
::NumberType,
StandardMatrixTag > 
Add (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void SubtractEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix
< LhsDataType, LhsMatrixType >
::NumberType,
StandardMatrixTag > 
Subtract (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void NekMultiplyUnspecializedMatrixType (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void NekMultiplyDiagonalMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
 
template<typename DataType , typename LhsDataType >
void NekMultiplyDiagonalMatrix (DataType *result, const NekMatrix< LhsDataType, StandardMatrixTag > &lhs, const DataType *rhs)
 
template<typename LhsDataType , typename MatrixType >
void NekMultiplyBandedMatrix (NekDouble *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const NekDouble *rhs, typename boost::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > > >::type *p=0)
 
template<typename DataType , typename LhsDataType >
void NekMultiplyBandedMatrix (DataType *result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > > > >::type *p=0)
 
template<typename DataType , typename LhsInnerMatrixType >
void FullBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
 
template<typename LhsInnerMatrixType >
void DiagonalBlockMatrixMultiply (NekVector< double > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< double > &rhs)
 
void NekMultiplyLowerTriangularMatrix (NekDouble *result, const NekMatrix< NekDouble, StandardMatrixTag > &lhs, const NekDouble *rhs)
 
void NekMultiplyLowerTriangularMatrix (NekDouble *result, const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &lhs, const NekDouble *rhs)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void NekMultiplyLowerTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
 
void NekMultiplyUpperTriangularMatrix (NekDouble *result, const NekMatrix< NekDouble, StandardMatrixTag > &lhs, const NekDouble *rhs)
 
void NekMultiplyUpperTriangularMatrix (NekDouble *result, const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &lhs, const NekDouble *rhs)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void NekMultiplyUpperTriangularMatrix (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
 
template<typename InnerMatrixType , typename MatrixTag >
void NekMultiplyFullMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > >::type *p=0)
 
template<typename InnerMatrixType , typename MatrixTag >
void NekMultiplyFullMatrix (NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *p=0)
 
template<typename DataType , typename LhsDataType , typename MatrixType >
void Multiply (DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_STANDARD_AND_SCALED_MATRICES,(1,(void)),(1,(NekVector< NekDouble > &)),(1,(const NekVector< NekDouble > &)))
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_BLOCK_MATRIX_TYPES,(1,(void)),(1,(NekVector< NekDouble > &)),(1,(const NekVector< NekDouble > &)))
 
 NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(NekVector< NekDouble >)),(0,()),(1,(const NekVector< NekDouble > &)))
 
template<typename DataType >
std::vector< NekVector
< DataType > > 
GramSchmidtOrthogonalization (const std::vector< NekVector< DataType > > &x)
 Calculates the orthogonal, normalized vectors from linearly independent input. More...
 
template<typename DataType , typename FormType >
std::ostream & operator<< (std::ostream &os, const NekMatrix< DataType, FormType > &rhs)
 
template<typename DataType , typename FormType >
std::ostream & operator>> (std::ostream &os, const NekMatrix< DataType, FormType > &rhs)
 
 BOOST_TYPEOF_REGISTER_TEMPLATE (NekMatrix, 2)
 
template<typename DataType >
void negate (NekPoint< DataType > &rhs)
 
template<typename DataType >
NekPoint< DataType > operator+ (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType >
NekPoint< DataType > operator+ (typename boost::call_traits< DataType >::const_reference lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType >
NekPoint< DataType > operator+ (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::const_reference rhs)
 
template<typename DataType >
NekPoint< DataType > operator- (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType >
NekPoint< DataType > operator- (typename boost::call_traits< DataType >::const_reference lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType >
NekPoint< DataType > operator- (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::const_reference rhs)
 
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint< DataType > operator* (const ScalarType &lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint< DataType > operator* (const NekPoint< DataType > &lhs, const ScalarType &rhs)
 
template<typename DataType >
NekPoint< DataType > operator/ (const NekPoint< DataType > &lhs, typename boost::call_traits< DataType >::param_type rhs)
 
template<typename DataType >
boost::call_traits< DataType >
::value_type 
distanceBetween (const NekPoint< DataType > &lhs, const NekPoint< DataType > &rhs)
 
template<typename DataType >
bool fromString (const std::string &str, NekPoint< DataType > &result)
 
template<typename DataType >
std::ostream & operator<< (std::ostream &os, const NekPoint< DataType > &p)
 
template<typename DataType >
void Add (NekVector< DataType > &result, const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template<typename DataType >
void AddNegatedLhs (NekVector< DataType > &result, const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template void Add (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template void AddNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
void AddEqual (NekVector< DataType > &result, const NekVector< DataType > &rhs)
 
template<typename DataType >
void AddEqualNegatedLhs (NekVector< DataType > &result, const NekVector< DataType > &rhs)
 
template void AddEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
 
template void AddEqualNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
 
template<typename LhsDataType , typename RhsDataType >
NekVector< LhsDataTypeAdd (const NekVector< LhsDataType > &lhs, const NekVector< RhsDataType > &rhs)
 
template NekVector< NekDoubleAdd (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void Subtract (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void SubtractNegatedLhs (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
 
template void Subtract (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template void SubtractNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void SubtractEqual (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void SubtractEqualNegatedLhs (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
 
template void SubtractEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
 
template void SubtractEqualNegatedLhs (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
NekVector< DataType > Subtract (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template NekVector< NekDoubleSubtract (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
 
template void Divide (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
 
template<typename ResultDataType >
void DivideEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
 
template void DivideEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
 
template<typename DataType >
NekVector< DataType > Divide (const NekVector< DataType > &lhs, const NekDouble &rhs)
 
template NekVector< NekDoubleDivide (const NekVector< NekDouble > &lhs, const NekDouble &rhs)
 
template<typename ResultDataType , typename InputDataType >
void Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekVector< InputDataType > &rhs)
 
template void Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void MultiplyEqual (NekVector< ResultDataType > &result, const NekVector< InputDataType > &rhs)
 
template void MultiplyEqual (NekVector< NekDouble > &result, const NekVector< NekDouble > &rhs)
 
template<typename DataType , typename InputDataType >
NekVector< DataType > Multiply (const NekVector< DataType > &lhs, const NekVector< InputDataType > &rhs)
 
template NekVector< NekDoubleMultiply (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)
 
template void Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)
 
template<typename ResultDataType >
void MultiplyEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)
 
template void MultiplyEqual (NekVector< NekDouble > &result, const NekDouble &rhs)
 
template<typename DataType >
NekVector< DataType > Multiply (const NekVector< DataType > &lhs, const NekDouble &rhs)
 
template NekVector< NekDoubleMultiply (const NekVector< NekDouble > &lhs, const NekDouble &rhs)
 
template<typename ResultDataType , typename InputDataType >
void Multiply (NekVector< ResultDataType > &result, const NekDouble &lhs, const NekVector< InputDataType > &rhs)
 
template<typename ResultDataType , typename InputDataType >
void MultiplyInvertedLhs (NekVector< ResultDataType > &result, const NekDouble &lhs, const NekVector< InputDataType > &rhs)
 
template void MultiplyInvertedLhs (NekVector< NekDouble > &result, const NekDouble &lhs, const NekVector< NekDouble > &rhs)
 
template void Multiply (NekVector< NekDouble > &result, const NekDouble &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
NekVector< DataType > Multiply (const DataType &lhs, const NekVector< DataType > &rhs)
 
template NekVector< NekDoubleMultiply (const NekDouble &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
std::ostream & operator<< (std::ostream &os, const NekVector< DataType > &rhs)
 
template std::ostream & operator<< (std::ostream &os, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
NekVector< DataType > createVectorFromPoints (const NekPoint< DataType > &source, const NekPoint< DataType > &dest)
 
template NekVector< NekDoublecreateVectorFromPoints (const NekPoint< NekDouble > &source, const NekPoint< NekDouble > &dest)
 
template<typename DataType >
NekPoint< DataType > findPointAlongVector (const NekVector< DataType > &lhs, const DataType &t)
 
template NekPoint< NekDoublefindPointAlongVector (const NekVector< NekDouble > &lhs, const NekDouble &t)
 
template<typename DataType >
bool operator== (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template bool operator== (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
bool operator!= (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template bool operator!= (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
std::vector< DataType > FromString (const std::string &str)
 
template<typename DataType >
DataType L1Norm (const NekVector< DataType > &v)
 
template NekDouble L1Norm (const NekVector< NekDouble > &v)
 
template<typename DataType >
DataType L2Norm (const NekVector< DataType > &v)
 
template NekDouble L2Norm (const NekVector< NekDouble > &v)
 
template<typename DataType >
DataType InfinityNorm (const NekVector< DataType > &v)
 
template NekDouble InfinityNorm (const NekVector< NekDouble > &v)
 
template<typename DataType >
NekVector< DataType > Negate (const NekVector< DataType > &v)
 
template NekVector< NekDoubleNegate (const NekVector< NekDouble > &v)
 
template<typename DataType >
void NegateInPlace (NekVector< DataType > &v)
 
template void NegateInPlace (NekVector< NekDouble > &v)
 
template<typename DataType >
DataType Magnitude (const NekVector< DataType > &v)
 
template NekDouble Magnitude (const NekVector< NekDouble > &v)
 
template<typename DataType >
DataType Dot (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template NekDouble Dot (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
void Normalize (NekVector< DataType > &v)
 
template void Normalize (NekVector< NekDouble > &v)
 
void NegateInPlace (NekDouble &v)
 
void InvertInPlace (NekDouble &v)
 
template<typename DataType >
NekVector< DataType > Cross (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)
 
template NekVector< NekDoubleCross (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
 
template<typename DataType >
std::string AsString (const NekVector< DataType > &v)
 
template std::string AsString (const NekVector< NekDouble > &v)
 
 BOOST_TYPEOF_REGISTER_TEMPLATE (NekVector, 1)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekVector, 1, NekDouble, 0)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekDouble, 0, NekVector, 1)
 
 GENERATE_MULTIPLICATION_OPERATOR (NekVector, 1, NekVector, 1)
 
 GENERATE_DIVISION_OPERATOR (NekVector, 1, NekDouble, 0)
 
 GENERATE_ADDITION_OPERATOR (NekVector, 1, NekVector, 1)
 
 GENERATE_SUBTRACTION_OPERATOR (NekVector, 1, NekVector, 1)
 
template<typename DataType >
NekMatrix< DataType,
ScaledMatrixTag > 
Transpose (NekMatrix< DataType, ScaledMatrixTag > &rhs)
 
template NekMatrix< NekMatrix
< NekDouble, StandardMatrixTag >
, ScaledMatrixTag > 
Transpose (NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &rhs)
 
template<typename DataType >
void NegateInPlace (NekMatrix< DataType, ScaledMatrixTag > &v)
 
template void NegateInPlace (NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &v)
 
void convertCooToBco (const unsigned int blkRows, const unsigned int blkColumns, const unsigned int blkDim, const COOMatType &cooMat, BCOMatType &bcoMat)
 
template<typename SparseStorageType >
std::ostream & operator<< (std::ostream &os, const NekSparseMatrix< SparseStorageType > &rhs)
 
template<typename SparseStorageType >
std::ostream & operator<< (std::ostream &os, const NekSparseDiagBlkMatrix< SparseStorageType > &rhs)
 
template std::ostream & operator<< (std::ostream &os, const NekSparseMatrix< StorageSmvBsr< NekDouble > > &rhs)
 
template std::ostream & operator<< (std::ostream &os, const NekSparseDiagBlkMatrix< StorageSmvBsr< NekDouble > > &rhs)
 
template<typename DataType >
NekMatrix< DataType,
StandardMatrixTag > 
Transpose (NekMatrix< DataType, StandardMatrixTag > &rhs)
 
template NekMatrix< NekDouble,
StandardMatrixTag > 
Transpose (NekMatrix< NekDouble, StandardMatrixTag > &rhs)
 
template<typename DataType >
void NegateInPlace (NekMatrix< DataType, StandardMatrixTag > &m)
 
template void NegateInPlace (NekMatrix< double, StandardMatrixTag > &v)
 
template<typename DataType >
bool operator== (const MemoryManager< DataType > &lhs, const MemoryManager< DataType > &rhs)
 
template<typename DataType >
bool operator!= (const MemoryManager< DataType > &lhs, const MemoryManager< DataType > &rhs)
 
MemPoolGetMemoryPool ()
 
CellModelFactoryGetCellModelFactory ()
 
ProtocolFactoryGetProtocolFactory ()
 
StimulusFactoryGetStimulusFactory ()
 
NekDouble guessp (NekDouble g[], NekDouble rhoL, NekDouble uL, NekDouble pL, NekDouble cL, NekDouble rhoR, NekDouble uR, NekDouble pR, NekDouble cR)
 Use either PVRS, two-rarefaction or two-shock Riemann solvers to calculate an initial pressure for the Newton-Raphson scheme. More...
 
void prefun (NekDouble *g, NekDouble p, NekDouble dk, NekDouble pk, NekDouble ck, NekDouble &f, NekDouble &fd)
 Evaluate pressure functions fL and fR in Newton iteration of Riemann solver (see equation 4.85 and 4.86 of Toro 2009). More...
 
ExtrapolateFactoryGetExtrapolateFactory ()
 
DNekMat MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom)
 
BoundaryFactoryGetBoundaryFactory ()
 
PressureAreaFactoryGetPressureAreaFactory ()
 

Variables

StandardMatrixTag
boost::call_traits
< LhsDataType >
::const_reference rhs typedef
NekMatrix< LhsDataType,
StandardMatrixTag >::iterator 
iterator
 
const char *const FlagTypeMap []
 String map for FlagType enumeration. More...
 
static FlagList NullFlagList
 An empty flag list. More...
 
static Array< OneD, int > NullInt1DArray
 
static Array< OneD, NekDoubleNullNekDouble1DArray
 
static Array< OneD, Array
< OneD, NekDouble > > 
NullNekDoubleArrayofArray
 
 LhsDataType
 
 RhsMatrixType
 
 RhsDataType
 
StandardMatrixTag & lhs
 
 LhsMatrixType
 
 NEKTAR_ALL_MATRIX_TYPES
 
 void
 
static DNekMatSharedPtr NullDNekMatSharedPtr
 
static DNekScalMatSharedPtr NullDNekScalMatSharedPtr
 
static DNekScalBlkMatSharedPtr NullDNekScalBlkMatSharedPtr
 
static const int NistSpBlasDescra [5][9]
 
static NekDouble EigenvaluesRegMeshes [10][14]
 
static NekDouble EigenvaluesAnaMeshesAB2 [6][14]
 
static NekDouble EigenvaluesAnaMeshesRK2 [6][14]
 
static NekDouble EigenvaluesAnaMeshesRK4 [6][14]
 
const char *const ProblemTypeMap []
 
const std::string kEquationTypeStr []
 
const std::string kAdvectionFormStr []
 
static PulseWaveBoundarySharedPtr NullPulseWaveBoundarySharedPtr
 
static
PulseWavePressureAreaSharedPtr 
NullPulseWavePressureAreaSharedPtr
 
const char *const UpwindTypeMapPulse []
 
const std::string VWIIterationTypeMap []
 
static char const kDefaultState [] = "default"
 

Detailed Description

<

class for meshing individual curves (1d meshing)

Todo:
: forward declare
Todo:
: forward declare
Todo:
: forward declare

Typedef Documentation

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file ArterialPressureArea.h.

Definition at line 64 of file SparseMatrixFwd.hpp.

Definition at line 65 of file SparseMatrixFwd.hpp.

typedef BCOMatType::const_iterator Nektar::BCOMatTypeConstIt

Definition at line 66 of file SparseMatrixFwd.hpp.

typedef boost::shared_ptr<BCOMatType> Nektar::BCOMatTypeSharedPtr

Definition at line 67 of file SparseMatrixFwd.hpp.

Definition at line 68 of file SparseMatrixFwd.hpp.

typedef NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatDNekBlkMat

Definition at line 64 of file NekTypeDefs.hpp.

Definition at line 73 of file NekTypeDefs.hpp.

typedef NekMatrix<NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatDNekScalBlkMat

Definition at line 68 of file NekTypeDefs.hpp.

Definition at line 75 of file NekTypeDefs.hpp.

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 61 of file NekTypeDefs.hpp.

Definition at line 56 of file PulseWaveBoundary.h.

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 61 of file CellModel.h.

typedef boost::shared_ptr<CellModel> Nektar::CellModelSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 56 of file CellModel.h.

Definition at line 57 of file SparseMatrixFwd.hpp.

Definition at line 58 of file SparseMatrixFwd.hpp.

typedef COOMatType::const_iterator Nektar::COOMatTypeConstIt

Definition at line 59 of file SparseMatrixFwd.hpp.

typedef boost::shared_ptr<COOMatType> Nektar::COOMatTypeSharedPtr

Definition at line 60 of file SparseMatrixFwd.hpp.

Definition at line 61 of file SparseMatrixFwd.hpp.

typedef std::pair<IndexType, IndexType> Nektar::CoordType

Definition at line 56 of file SparseMatrixFwd.hpp.

Definition at line 63 of file CoupledAssemblyMap.h.

Definition at line 65 of file CoupledLocalToGlobalC0ContMap.h.

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DenseMatrix

Definition at line 53 of file NekTypeDefs.hpp.

typedef NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, BlockMatrixTag> Nektar::DNekBlkMat

Definition at line 60 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<DNekBlkMat> Nektar::DNekBlkMatSharedPtr

Definition at line 72 of file NekTypeDefs.hpp.

Definition at line 83 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<DNekLinSys> Nektar::DNekLinSysSharedPtr

Definition at line 84 of file NekTypeDefs.hpp.

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DNekMat

Definition at line 52 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<DNekMat> Nektar::DNekMatSharedPtr

Definition at line 70 of file NekTypeDefs.hpp.

typedef NekMatrix<NekMatrix<NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag> Nektar::DNekScalBlkMat

Definition at line 66 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<DNekScalBlkMat> Nektar::DNekScalBlkMatSharedPtr

Definition at line 74 of file NekTypeDefs.hpp.

Definition at line 86 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<DNekScalLinSys> Nektar::DNekScalLinSysSharedPtr

Definition at line 87 of file NekTypeDefs.hpp.

typedef NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > Nektar::DNekScalMat

Definition at line 72 of file NekMatrixFwd.hpp.

typedef boost::shared_ptr< DNekScalMat > Nektar::DNekScalMatSharedPtr

Definition at line 73 of file NekMatrixFwd.hpp.

Definition at line 49 of file NekTypeDefs.hpp.

Definition at line 79 of file Extrapolate.h.

typedef boost::shared_ptr<Extrapolate> Nektar::ExtrapolateSharedPtr

Definition at line 72 of file Extrapolate.h.

typedef std::pair<std::string, FilterParams> Nektar::FilterMap

Definition at line 49 of file FilterMovingBody.h.

Definition at line 45 of file FilterMovingBody.h.

typedef std::map<std::string, std::string> Nektar::FilterParams

Definition at line 48 of file FilterMovingBody.h.

Definition at line 238 of file IncNavierStokes.h.

typedef unsigned int Nektar::IndexType

Definition at line 51 of file SparseMatrixFwd.hpp.

Definition at line 53 of file SparseMatrixFwd.hpp.

typedef boost::shared_ptr<InterfacePoint> Nektar::InterfacePointShPtr

Definition at line 83 of file PulseWaveSystem.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file LymphaticPressureArea.h.

Definition at line 48 of file MappingExtrapolate.h.

typedef double Nektar::NekDouble

Definition at line 44 of file NektarUnivTypeDefs.hpp.

typedef boost::int32_t Nektar::NekInt

Definition at line 46 of file NektarUnivTypeDefs.hpp.

typedef boost::int32_t Nektar::NekInt32

Definition at line 47 of file NektarUnivTypeDefs.hpp.

typedef boost::int64_t Nektar::NekInt64

Definition at line 48 of file NektarUnivTypeDefs.hpp.

Definition at line 54 of file PulseWavePressureArea.h.

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 54 of file Protocol.h.

typedef boost::shared_ptr<Protocol> Nektar::ProtocolSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 45 of file Protocol.h.

Definition at line 47 of file PulseWaveBoundary.h.

Definition at line 46 of file PulseWavePressureArea.h.

Definition at line 77 of file PulseWaveSystemOutput.h.

Definition at line 186 of file PulseWaveSystem.h.

typedef boost::shared_ptr<QInflow> Nektar::QInflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file QInflow.h.

typedef boost::shared_ptr<RCROutflow> Nektar::RCROutflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file RCROutflow.h.

typedef boost::shared_ptr<ROutflow> Nektar::ROutflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file ROutflow.h.

typedef NekMatrix<DenseMatrix, ScaledMatrixTag> Nektar::ScaledMatrix

Definition at line 57 of file NekTypeDefs.hpp.

typedef boost::shared_ptr<NekMatrix<NekDouble, StandardMatrixTag> > Nektar::SharedNekMatrixPtr

Definition at line 71 of file NekMatrixFwd.hpp.

Definition at line 54 of file StandardExtrapolate.h.

Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class.

Definition at line 60 of file Stimulus.h.

typedef boost::shared_ptr<Stimulus> Nektar::StimulusSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 50 of file Stimulus.h.

Definition at line 54 of file SubSteppingExtrapolate.h.

typedef std::vector<std::pair<std::string, std::string> > Nektar::SummaryList

Definition at line 51 of file CellModel.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TerminalOutflow.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file TimeDependentInflow.h.

Pointer to a PulseWaveOutflow object.

Definition at line 45 of file UndefinedInOutflow.h.

typedef boost::shared_ptr<VCSMapping> Nektar::VCSMappingSharedPtr

Definition at line 155 of file VCSMapping.h.

Definition at line 167 of file VelocityCorrectionScheme.h.

Enumeration Type Documentation

Enumerator
eNoAdvectionForm 
eConvective 
eNonConservative 
eLinearised 
eAdjoint 
eSkewSymmetric 
eNoAdvection 
eAdvectionFormSize 

Definition at line 76 of file IncNavierStokes.h.

Enumerator
eVECTOR_WRAPPER 

Definition at line 460 of file SharedArray.hpp.

461  {
463  };
Enumerator
xDir 
yDir 
zDir 

Definition at line 68 of file NektarUnivTypeDefs.hpp.

69  {
70  xDir = 0,
71  yDir = 1,
72  zDir = 2
73  };
Enumerator
eNoEquationType 
eSteadyStokes 
eSteadyOseen 
eSteadyLinearisedNS 
eUnsteadyStokes 
eUnsteadyLinearisedNS 
eUnsteadyNavierStokes 
eSteadyNavierStokes 
eEquationTypeSize 

Definition at line 49 of file IncNavierStokes.h.

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal 

Definition at line 85 of file NektarUnivTypeDefs.hpp.

Enumerator
eFULL 
eDIAGONAL 
eUPPER_TRIANGULAR 
eLOWER_TRIANGULAR 
eSYMMETRIC 
ePOSITIVE_DEFINITE_SYMMETRIC 
eBANDED 
eSYMMETRIC_BANDED 
ePOSITIVE_DEFINITE_SYMMETRIC_BANDED 
eUPPER_TRIANGULAR_BANDED 
eLOWER_TRIANGULAR_BANDED 

Definition at line 42 of file MatrixStorageType.h.

Enumerator
eTecplot 
eTecplotZones 
eTecplotSingleBlock 
eGmsh 
eGnuplot 

Definition at line 75 of file NektarUnivTypeDefs.hpp.

Specifies if the pointer passed to a NekMatrix or NekVector is copied into an internal representation or used directly.

Enumerator
eWrapper 
eCopy 

Definition at line 43 of file PointerWrapper.h.

44  {
45  eWrapper,
46  eCopy
47  };
Enumerator
eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eIsentropicVortex 

Isentropic Vortex.

eRinglebFlow 

Ringleb Flow.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eSolitaryWave 

First order Laitone solitary wave.

SIZE_ProblemType 

Length of enum list.

Definition at line 43 of file EulerCFE.h.

44  {
45  eGeneral, ///< No problem defined - Default Inital data
46  eIsentropicVortex, ///< Isentropic Vortex
47  eRinglebFlow, ///< Ringleb Flow
48  SIZE_ProblemType ///< Length of enum list
49  };
No problem defined - Default Inital data.
Definition: EulerADCFE.h:46
Ringleb Flow.
Definition: EulerCFE.h:47
Length of enum list.
Definition: EulerADCFE.h:47
Isentropic Vortex.
Definition: EulerCFE.h:46
Enumerator
eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eIsentropicVortex 

Isentropic Vortex.

eRinglebFlow 

Ringleb Flow.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eSolitaryWave 

First order Laitone solitary wave.

SIZE_ProblemType 

Length of enum list.

Definition at line 44 of file NavierStokesCFE.h.

45  {
46  eGeneral, ///< No problem defined - Default Inital data
47  SIZE_ProblemType ///< Length of enum list
48  };
No problem defined - Default Inital data.
Definition: EulerADCFE.h:46
Length of enum list.
Definition: EulerADCFE.h:47
Enumerator
eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eIsentropicVortex 

Isentropic Vortex.

eRinglebFlow 

Ringleb Flow.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eSolitaryWave 

First order Laitone solitary wave.

SIZE_ProblemType 

Length of enum list.

Definition at line 44 of file EulerADCFE.h.

45  {
46  eGeneral, ///< No problem defined - Default Inital data
47  SIZE_ProblemType ///< Length of enum list
48  };
No problem defined - Default Inital data.
Definition: EulerADCFE.h:46
Length of enum list.
Definition: EulerADCFE.h:47
Enumerator
eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eIsentropicVortex 

Isentropic Vortex.

eRinglebFlow 

Ringleb Flow.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

SIZE_ProblemType 

Length of enum list.

eGeneral 

No problem defined - Default Inital data.

eSolitaryWave 

First order Laitone solitary wave.

SIZE_ProblemType 

Length of enum list.

Definition at line 45 of file NonlinearPeregrine.h.

46 {
47  eGeneral, ///< No problem defined - Default Inital data
48  eSolitaryWave, ///< First order Laitone solitary wave
49  SIZE_ProblemType ///< Length of enum list
50 };
No problem defined - Default Inital data.
Definition: EulerADCFE.h:46
Length of enum list.
Definition: EulerADCFE.h:47
First order Laitone solitary wave.
Enumerator
eNotSetPulse 

flux not defined

eUpwindPulse 

simple upwinding scheme

SIZE_UpwindTypePulse 

Length of enum list.

Definition at line 46 of file PulseWaveSystem.h.

47  {
48  eNotSetPulse, ///< flux not defined
49  eUpwindPulse, ///< simple upwinding scheme
50  SIZE_UpwindTypePulse ///< Length of enum list
51  };
Length of enum list.
flux not defined
simple upwinding scheme
Enumerator
eFixedAlpha 
eFixedWaveForcing 
eFixedAlphaWaveForcing 
eFixedWaveForcingWithSubIterationOnAlpha 
eVWIIterationTypeSize 

Definition at line 55 of file VortexWaveInteraction.h.

Function Documentation

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat void Nektar::Add ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 214 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Add().

217  {
218  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
219  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
220  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
221  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
222  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
223  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
224 
225  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
226  {
227  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
228  {
229  result(i,j) = lhs(i,j) + rhs(i,j);
230  }
231  }
232  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void Nektar::Add ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 214 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Add().

217  {
218  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
219  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
220  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
221  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
222  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
223  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
224 
225  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
226  {
227  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
228  {
229  result(i,j) = lhs(i,j) + rhs(i,j);
230  }
231  }
232  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Add ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 261 of file MatrixOperations.cpp.

References Add().

263  {
264  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
265  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
266  Add(result, lhs, rhs);
267  return result;
268  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Add ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 261 of file MatrixOperations.cpp.

References Add().

263  {
264  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
265  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
266  Add(result, lhs, rhs);
267  return result;
268  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Add(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType >
void Nektar::Add ( NekVector< DataType > &  result,
const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 431 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

434  {
435  DataType* r_buf = result.GetRawPtr();
436  const DataType* lhs_buf = lhs.GetRawPtr();
437  const DataType* rhs_buf = rhs.GetRawPtr();
438  const unsigned int ldim = lhs.GetDimension();
439  for(int i = 0; i < ldim; ++i)
440  {
441  r_buf[i] = lhs_buf[i] + rhs_buf[i];
442  }
443  }
StandardMatrixTag & lhs
template void Nektar::Add ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename LhsDataType , typename RhsDataType >
NekVector< LhsDataType > Nektar::Add ( const NekVector< LhsDataType > &  lhs,
const NekVector< RhsDataType > &  rhs 
)

Definition at line 502 of file NekVector.cpp.

References Add(), and Nektar::NekVector< DataType >::GetDimension().

504  {
505  NekVector<LhsDataType> result(lhs.GetDimension());
506  Add(result, lhs, rhs);
507  return result;
508  }
template NekVector< NekDouble > Add(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template NekVector<NekDouble> Nektar::Add ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
void Nektar::AddEqual ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 169 of file MatrixOperations.cpp.

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator+=().

171  {
172  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
173  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
174  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
175  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
176  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
177  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
178 
179  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
180  {
181  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
182  {
183  result(i,j) += rhs(i,j);
184  }
185  }
186  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType >
void Nektar::AddEqual ( NekVector< DataType > &  result,
const NekVector< DataType > &  rhs 
)

Definition at line 468 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

470  {
471  DataType* r_buf = result.GetRawPtr();
472  const DataType* rhs_buf = rhs.GetRawPtr();
473  const unsigned int rdim = rhs.GetDimension();
474  for(int i = 0; i < rdim; ++i)
475  {
476  r_buf[i] += rhs_buf[i];
477  }
478  }
template void Nektar::AddEqual ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void Nektar::AddEqualNegatedLhs ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 190 of file MatrixOperations.cpp.

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

192  {
193  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
194  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
195  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
196  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
197  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
198  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
199 
200  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
201  {
202  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
203  {
204  result(i,j) = -result(i,j) + rhs(i,j);
205  }
206  }
207  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType >
void Nektar::AddEqualNegatedLhs ( NekVector< DataType > &  result,
const NekVector< DataType > &  rhs 
)

Definition at line 481 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

483  {
484  DataType* r_buf = result.GetRawPtr();
485  const DataType* rhs_buf = rhs.GetRawPtr();
486  const unsigned int rdim = rhs.GetDimension();
487  for(int i = 0; i < rdim; ++i)
488  {
489  r_buf[i] = -r_buf[i] + rhs_buf[i];
490  }
491  }
template void Nektar::AddEqualNegatedLhs ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void Nektar::AddNegatedLhs ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 235 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

238  {
239  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
240  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
241  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be added."));
242  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
243  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
244  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be added."));
245 
246  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
247  {
248  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
249  {
250  result(i,j) = -lhs(i,j) + rhs(i,j);
251  }
252  }
253  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType >
void Nektar::AddNegatedLhs ( NekVector< DataType > &  result,
const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 446 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

449  {
450  DataType* r_buf = result.GetRawPtr();
451  const DataType* lhs_buf = lhs.GetRawPtr();
452  const DataType* rhs_buf = rhs.GetRawPtr();
453  const unsigned int ldim = lhs.GetDimension();
454  for(int i = 0; i < ldim; ++i)
455  {
456  r_buf[i] = -lhs_buf[i] + rhs_buf[i];
457  }
458  }
StandardMatrixTag & lhs
template void Nektar::AddNegatedLhs ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
std::string Nektar::AsString ( const NekVector< DataType > &  v)

Definition at line 1045 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRows().

Referenced by Nektar::NekVector< DataType >::AsString().

1046  {
1047  unsigned int d = v.GetRows();
1048  std::string result = "(";
1049  for(unsigned int i = 0; i < d; ++i)
1050  {
1051  result += boost::lexical_cast<std::string>(v[i]);
1052  if( i < v.GetDimension()-1 )
1053  {
1054  result += ", ";
1055  }
1056  }
1057  result += ")";
1058  return result;
1059  }
template std::string Nektar::AsString ( const NekVector< NekDouble > &  v)
Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE ( NekMatrix  ,
 
)
Nektar::BOOST_TYPEOF_REGISTER_TEMPLATE ( NekVector  ,
 
)
void Nektar::convertCooToBco ( const unsigned int  blkRows,
const unsigned int  blkColumns,
const unsigned int  blkDim,
const COOMatType &  cooMat,
BCOMatType &  bcoMat 
)

Definition at line 48 of file SparseUtils.cpp.

Referenced by Nektar::MultiRegions::GlobalMatrix::GlobalMatrix(), and Nektar::MultiRegions::GlobalLinSysIterativeStaticCond::v_AssembleSchurComplement().

54  {
55  COOMatTypeConstIt entry;
57  int rowcoord, localRow, blkRowCoord;
58  int colcoord, localCol, blkColCoord;
59 
60  for(entry = cooMat.begin(); entry != cooMat.end(); entry++)
61  {
62  rowcoord = (entry->first).first;
63  colcoord = (entry->first).second;
64 
65  blkRowCoord = rowcoord / blkDim;
66  blkColCoord = colcoord / blkDim;
67 
68  CoordType blkCoords = std::make_pair(blkRowCoord,blkColCoord);
69  blk = bcoMat.find(blkCoords);
70  if (blk == bcoMat.end())
71  {
72  BCOEntryType b(blkDim*blkDim, 0.0);
73  bcoMat[blkCoords] = b;
74  }
75 
76  localRow = rowcoord % blkDim;
77  localCol = colcoord % blkDim;
78 
79  // transpose it: NIST SpBLAS expects Fortran ordering
80  // of dense subblocks
81  const unsigned int localoffset = localRow + localCol*blkDim;
82  (bcoMat[blkCoords])[localoffset] = entry->second;
83  }
84  }
COOMatType::const_iterator COOMatTypeConstIt
BCOMatType::const_iterator BCOMatTypeConstIt
Array< OneD, NekDouble > BCOEntryType
std::pair< IndexType, IndexType > CoordType
template<typename ConstDataType , typename DataType >
void Nektar::CopyArray ( const Array< OneD, ConstDataType > &  source,
Array< OneD, DataType > &  dest 
)

Definition at line 762 of file SharedArray.hpp.

References Nektar::Array< OneD, DataType >::data(), and Nektar::Array< OneD, const DataType >::num_elements().

Referenced by Nektar::LinearSystem::LinearSystem(), Nektar::NekVector< DataType >::NekVector(), Nektar::StdRegions::StdExpansion0D::PhysTensorDeriv(), and Nektar::StdRegions::StdExpansion1D::PhysTensorDeriv().

763  {
764  if( dest.num_elements() != source.num_elements() )
765  {
766  dest = Array<OneD, DataType>(source.num_elements());
767  }
768 
769  std::copy(source.data(), source.data() + source.num_elements(), dest.data());
770  }
template<typename ConstDataType , typename DataType >
void Nektar::CopyArrayN ( const Array< OneD, ConstDataType > &  source,
Array< OneD, DataType > &  dest,
unsigned int  n 
)

Definition at line 773 of file SharedArray.hpp.

References Nektar::Array< OneD, DataType >::data(), and Nektar::Array< OneD, const DataType >::num_elements().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::NekMatrix(), Nektar::NekMatrix< DataType, StandardMatrixTag >::PerformCopyConstruction(), and Nektar::NekMatrix< DataType, StandardMatrixTag >::RemoveExcessCapacity().

774  {
775  if( dest.num_elements() != n )
776  {
777  dest = Array<OneD, DataType>(n);
778  }
779 
780  std::copy(source.data(), source.data() + n, dest.data());
781  }
template<typename Dim , typename DataType , typename ExtentListType >
boost::shared_ptr<boost::multi_array_ref<DataType, Dim::Value> > Nektar::CreateStorage ( const ExtentListType &  extent)

Definition at line 193 of file ArrayPolicies.hpp.

References Nektar::MemoryManager< DataType >::RawAllocate().

Referenced by Nektar::Array< OneD, const DataType >::Array().

194  {
195  typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
196  unsigned int size = std::accumulate(extent.begin(), extent.end(), 1,
197  std::multiplies<unsigned int>());
198  DataType* storage = MemoryManager<DataType>::RawAllocate(size);
199  return MemoryManager<ArrayType>::AllocateSharedPtrD(
200  boost::bind(DeleteStorage<DataType>, storage, size),
201  storage, extent);
202  }
template<typename DataType >
boost::shared_ptr<boost::multi_array_ref<DataType, 1> > Nektar::CreateStorage ( unsigned int  d1)

Definition at line 206 of file ArrayPolicies.hpp.

207  {
208  std::vector<unsigned int> extents(1, d1);
209  return CreateStorage<OneD, DataType>(extents);
210  }
template<typename DataType >
boost::shared_ptr<boost::multi_array_ref<DataType, 2> > Nektar::CreateStorage ( unsigned int  d1,
unsigned int  d2 
)

Definition at line 214 of file ArrayPolicies.hpp.

215  {
216  unsigned int vals[] = {d1, d2};
217  std::vector<unsigned int> extents(vals, vals+2);
218  return CreateStorage<TwoD, DataType>(extents);
219  }
template<typename DataType >
boost::shared_ptr<boost::multi_array_ref<DataType, 3> > Nektar::CreateStorage ( unsigned int  d1,
unsigned int  d2,
unsigned int  d3 
)

Definition at line 223 of file ArrayPolicies.hpp.

224  {
225  unsigned int vals[] = {d1, d2, d3};
226  std::vector<unsigned int> extents(vals, vals+3);
227  return CreateStorage<ThreeD, DataType>(extents);
228  }
template<typename DataType >
NekVector< DataType > Nektar::createVectorFromPoints ( const NekPoint< DataType > &  source,
const NekPoint< DataType > &  dest 
)

Definition at line 812 of file NekVector.cpp.

814  {
815  NekVector<DataType> result(3, 0.0);
816  for(unsigned int i = 0; i < 3; ++i)
817  {
818  result[i] = dest[i]-source[i];
819  }
820  return result;
821  }
template NekVector<NekDouble> Nektar::createVectorFromPoints ( const NekPoint< NekDouble > &  source,
const NekPoint< NekDouble > &  dest 
)
template<typename DataType >
NekVector< DataType > Nektar::Cross ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 1028 of file NekVector.cpp.

References ASSERTL1, Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::x(), Nektar::NekVector< DataType >::y(), and Nektar::NekVector< DataType >::z().

Referenced by Nektar::NekVector< DataType >::Cross().

1030  {
1031  ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3, "Cross is only valid for 3D vectors.");
1032 
1033  DataType first = lhs.y()*rhs.z() - lhs.z()*rhs.y();
1034  DataType second = lhs.z()*rhs.x() - lhs.x()*rhs.z();
1035  DataType third = lhs.x()*rhs.y() - lhs.y()*rhs.x();
1036 
1037  NekVector<DataType> result(first, second, third);
1038  return result;
1039  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template NekVector<NekDouble> Nektar::Cross ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
void Nektar::DeleteStorage ( DataType *  data,
unsigned int  num 
)

Definition at line 185 of file ArrayPolicies.hpp.

References Nektar::MemoryManager< DataType >::RawDeallocate().

186  {
187  ArrayDestructionPolicy<DataType>::Destroy(data, num);
188  MemoryManager<DataType>::RawDeallocate(data, num);
189  }
template<typename LhsInnerMatrixType >
void Nektar::DiagonalBlockMatrixMultiply ( NekVector< double > &  result,
const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &  lhs,
const NekVector< double > &  rhs 
)

Definition at line 203 of file MatrixVectorMultiplication.cpp.

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Nektar::NekVector< DataType >::GetRawPtr(), and Multiply().

Referenced by Multiply().

206  {
207  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
208  double* result_ptr = result.GetRawPtr();
209  const double* rhs_ptr = rhs.GetRawPtr();
210 
211  std::fill(result.begin(), result.end(), 0.0);
212 
213  unsigned int curResultRow = 0;
214  unsigned int curWrapperRow = 0;
215  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
216  {
217 
218  if( blockRow != 0 )
219  {
220  curResultRow += lhs.GetNumberOfRowsInBlockRow(blockRow-1);
221  }
222 
223  unsigned int blockColumn = blockRow;
224  if( blockColumn != 0 )
225  {
226  curWrapperRow += lhs.GetNumberOfColumnsInBlockColumn(blockColumn-1);
227  }
228 
229  unsigned int rowsInBlock = lhs.GetNumberOfRowsInBlockRow(blockRow);
230  if( rowsInBlock == 0 )
231  {
232  continue;
233  }
234 
235  unsigned int columnsInBlock = lhs.GetNumberOfColumnsInBlockColumn(blockColumn);
236  if( columnsInBlock == 0 )
237  {
238  continue;
239  }
240 
241  const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockColumn);
242  if( !block )
243  {
244  continue;
245  }
246 
247  double* resultWrapper = result_ptr + curResultRow;
248  const double* rhsWrapper = rhs_ptr + curWrapperRow;
249  Multiply(resultWrapper, *block, rhsWrapper);
250  //resultWrapper = (*block)*rhsWrapper;
251  }
252  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType >
boost::call_traits<DataType>::value_type Nektar::distanceBetween ( const NekPoint< DataType > &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 460 of file NekPoint.hpp.

462  {
463  DataType result = 0.0;
464  for(unsigned int i = 0; i < 3; ++i)
465  {
466  DataType temp = lhs[i] - rhs[i];
467  result += temp*temp;
468  }
469  return sqrt(result);
470  }
StandardMatrixTag & lhs
template<typename ResultDataType , typename InputDataType >
void Nektar::Divide ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  lhs,
const NekDouble &  rhs 
)

Definition at line 604 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Divide().

607  {
608  ResultDataType* r_buf = result.GetRawPtr();
609  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
610 
611  const unsigned int ldim = lhs.GetDimension();
612  for(int i = 0; i < ldim; ++i)
613  {
614  r_buf[i] = lhs_buf[i] / rhs;
615  }
616  }
StandardMatrixTag & lhs
template void Nektar::Divide ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekDouble &  rhs 
)
template<typename DataType >
NekVector< DataType > Nektar::Divide ( const NekVector< DataType > &  lhs,
const NekDouble &  rhs 
)

Definition at line 642 of file NekVector.cpp.

References Divide(), and Nektar::NekVector< DataType >::GetDimension().

644  {
645  NekVector<DataType> result(lhs.GetDimension());
646  Divide(result, lhs, rhs);
647  return result;
648  }
StandardMatrixTag & lhs
template NekVector< NekDouble > Divide(const NekVector< NekDouble > &lhs, const NekDouble &rhs)
template NekVector<NekDouble> Nektar::Divide ( const NekVector< NekDouble > &  lhs,
const NekDouble &  rhs 
)
template<typename ResultDataType >
void Nektar::DivideEqual ( NekVector< ResultDataType > &  result,
const NekDouble &  rhs 
)

Definition at line 624 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Nektar::NekVector< DataType >::operator/=().

626  {
627  ResultDataType* r_buf = result.GetRawPtr();
628 
629  const unsigned int resdim = result.GetDimension();
630  for(int i = 0; i < resdim; ++i)
631  {
632  r_buf[i] /= rhs;
633  }
634  }
template void Nektar::DivideEqual ( NekVector< NekDouble > &  result,
const NekDouble &  rhs 
)
template<typename DataType >
DataType Nektar::Dot ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 992 of file NekVector.cpp.

References ASSERTL1, and Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::Dot().

994  {
995  ASSERTL1( lhs.GetDimension() == rhs.GetDimension(), "Dot, dimension of the two operands must be identical.");
996 
997  DataType result = DataType(0);
998  const unsigned int ldim = lhs.GetDimension();
999  for(unsigned int i = 0; i < ldim; ++i)
1000  {
1001  result += lhs[i]*rhs[i];
1002  }
1003 
1004  return result;
1005  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template NekDouble Nektar::Dot ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
NekPoint< DataType > Nektar::findPointAlongVector ( const NekVector< DataType > &  lhs,
const DataType &  t 
)

Definition at line 829 of file NekVector.cpp.

831  {
832  NekPoint<DataType> result;
833  for(unsigned int i = 0; i < 3; ++i)
834  {
835  result[i] = lhs[i]*t;
836  }
837 
838  return result;
839  }
StandardMatrixTag & lhs
template NekPoint<NekDouble> Nektar::findPointAlongVector ( const NekVector< NekDouble > &  lhs,
const NekDouble &  t 
)
Nektar::for ( iterator  iter = lhs.begin(); iter != lhs.end(); ++iter)

Definition at line 100 of file MatrixOperations.cpp.

Referenced by ProjectMeshEllipsoidAndRefine(), and ProjectMeshSphereAndRefine().

101  {
102  *iter *= rhs;
103  }
template<typename DataType >
bool Nektar::fromString ( const std::string &  str,
NekPoint< DataType > &  result 
)

Definition at line 473 of file NekPoint.hpp.

References iterator.

Referenced by Nektar::NekPoint< NekDouble >::NekPoint().

474  {
475  try
476  {
477  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
478  boost::char_separator<char> sep("(<,>) ");
479  tokenizer tokens(str, sep);
480  unsigned int i = 0;
481  for(tokenizer::iterator iter = tokens.begin(); iter != tokens.end(); ++iter)
482  {
483  result[i] = boost::lexical_cast<DataType>(*iter);
484  ++i;
485  }
486 
487  return i == 3;
488  }
489  catch(boost::bad_lexical_cast&)
490  {
491  return false;
492  }
493  }
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
template<typename DataType >
std::vector< DataType > Nektar::FromString ( const std::string &  str)

Definition at line 873 of file NekVector.cpp.

References iterator.

874  {
875  std::vector<DataType> result;
876 
877  try
878  {
879  typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
880  boost::char_separator<char> sep("(<,>) ");
881  tokenizer tokens(str, sep);
882  for( tokenizer::iterator strIter = tokens.begin(); strIter != tokens.end(); ++strIter)
883  {
884  result.push_back(boost::lexical_cast<DataType>(*strIter));
885  }
886  }
887  catch(boost::bad_lexical_cast&)
888  {
889  }
890 
891  return result;
892  }
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs typedef NekMatrix< LhsDataType, StandardMatrixTag >::iterator iterator
template<typename DataType , typename LhsInnerMatrixType >
void Nektar::FullBlockMatrixMultiply ( NekVector< DataType > &  result,
const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 138 of file MatrixVectorMultiplication.cpp.

References Nektar::Array< OneD, DataType >::get(), Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::GetRawPtr(), and Multiply().

Referenced by Multiply().

141  {
142  unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
143  unsigned int numberOfBlockColumns = lhs.GetNumberOfBlockColumns();
144  DataType* result_ptr = result.GetRawPtr();
145  const DataType* rhs_ptr = rhs.GetRawPtr();
146 
147  for(unsigned int i = 0; i < result.GetDimension(); ++i)
148  {
149  result_ptr[i] = DataType(0);
150  }
151  Array<OneD, DataType> temp(result.GetDimension());
152  DataType* temp_ptr = temp.get();
153 
154  unsigned int curResultRow = 0;
155  for(unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
156  {
157  unsigned int rowsInBlock = lhs.GetNumberOfRowsInBlockRow(blockRow);
158 
159  if( blockRow != 0 )
160  {
161  curResultRow += lhs.GetNumberOfRowsInBlockRow(blockRow-1);
162  }
163 
164  if( rowsInBlock == 0 )
165  {
166  continue;
167  }
168 
169  DataType* resultWrapper = result_ptr + curResultRow;
170 
171  unsigned int curWrapperRow = 0;
172  for(unsigned int blockColumn = 0; blockColumn < numberOfBlockColumns; ++blockColumn)
173  {
174  if( blockColumn != 0 )
175  {
176  curWrapperRow += lhs.GetNumberOfColumnsInBlockColumn(blockColumn-1);
177  }
178 
179  //const boost::shared_ptr<const LhsInnerMatrixType>& block = lhs.GetBlock(blockRow, blockColumn);
180  const LhsInnerMatrixType* block = lhs.GetBlockPtr(blockRow, blockColumn);
181  if( !block )
182  {
183  continue;
184  }
185 
186  unsigned int columnsInBlock = lhs.GetNumberOfColumnsInBlockColumn(blockColumn);
187  if( columnsInBlock == 0 )
188  {
189  continue;
190  }
191 
192  const DataType* rhsWrapper = rhs_ptr + curWrapperRow;
193  Multiply(temp_ptr, *block, rhsWrapper);
194  for(unsigned int i = 0; i < rowsInBlock; ++i)
195  {
196  resultWrapper[i] += temp_ptr[i];
197  }
198  }
199  }
200  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
Nektar::GENERATE_ADDITION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_ADDITION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
Nektar::GENERATE_DIVISION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_DIVISION_OPERATOR ( NekVector  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekDouble  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekMatrix  ,
,
NekVector  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekVector  ,
,
NekDouble  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekDouble  ,
,
NekVector  ,
 
)
Nektar::GENERATE_MULTIPLICATION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
Nektar::GENERATE_SUBTRACTION_OPERATOR ( NekMatrix  ,
,
NekMatrix  ,
 
)
Nektar::GENERATE_SUBTRACTION_OPERATOR ( NekVector  ,
,
NekVector  ,
 
)
BoundaryFactory & Nektar::GetBoundaryFactory ( )

Definition at line 69 of file PulseWaveBoundary.cpp.

Referenced by Nektar::PulseWavePropagation::SetPulseWaveBoundaryConditions().

70  {
71  typedef Loki::SingletonHolder<BoundaryFactory,
72  Loki::CreateUsingNew,
73  Loki::NoDestroy > Type;
74  return Type::Instance();
75  }
LibUtilities::NekFactory< std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr & > BoundaryFactory
CellModelFactory & Nektar::GetCellModelFactory ( )

Definition at line 47 of file CellModel.cpp.

Referenced by main(), Nektar::BidomainRoth::v_InitObject(), Nektar::Bidomain::v_InitObject(), and Nektar::Monodomain::v_InitObject().

48  {
49  typedef Loki::SingletonHolder<CellModelFactory,
50  Loki::CreateUsingNew,
51  Loki::NoDestroy > Type;
52  return Type::Instance();
53  }
LibUtilities::NekFactory< std::string, CellModel, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr & > CellModelFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: CellModel.h:61
ExtrapolateFactory & Nektar::GetExtrapolateFactory ( )

Definition at line 50 of file Extrapolate.cpp.

Referenced by Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::VCSMapping::v_InitObject(), and Nektar::CoupledLinearNS::v_InitObject().

51  {
52  typedef Loki::SingletonHolder<ExtrapolateFactory,
53  Loki::CreateUsingNew,
54  Loki::NoDestroy,
55  Loki::SingleThreaded > Type;
56  return Type::Instance();
57  }
LibUtilities::NekFactory< std::string, Extrapolate, const LibUtilities::SessionReaderSharedPtr &, Array< OneD, MultiRegions::ExpListSharedPtr > &, MultiRegions::ExpListSharedPtr &, const Array< OneD, int > &, const SolverUtils::AdvectionSharedPtr & > ExtrapolateFactory
Definition: Extrapolate.h:79
MemPool & Nektar::GetMemoryPool ( )

Definition at line 37 of file ThreadSpecificPool.cpp.

Referenced by Nektar::MemoryManager< DataType >::Deallocate(), Nektar::MemoryManager< DataType >::RawAllocate(), and Nektar::MemoryManager< DataType >::RawDeallocate().

38  {
39  typedef Loki::SingletonHolder<MemPool ,
40  Loki::CreateUsingNew,
41  Loki::NoDestroy,
42  Loki::SingleThreaded> Type;
43  return Type::Instance();
44  }
PressureAreaFactory & Nektar::GetPressureAreaFactory ( )

Definition at line 64 of file PulseWavePressureArea.cpp.

Referenced by Nektar::PulseWavePropagation::v_InitObject().

65  {
66  typedef Loki::SingletonHolder<PressureAreaFactory,
67  Loki::CreateUsingNew,
68  Loki::NoDestroy > Type;
69  return Type::Instance();
70  }
LibUtilities::NekFactory< std::string, PulseWavePressureArea, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr & > PressureAreaFactory
ProtocolFactory & Nektar::GetProtocolFactory ( )

Definition at line 40 of file Protocol.cpp.

Referenced by Nektar::Stimulus::Stimulus().

41  {
42  typedef Loki::SingletonHolder<ProtocolFactory,
43  Loki::CreateUsingNew,
44  Loki::NoDestroy > Type;
45  return Type::Instance();
46  }
LibUtilities::NekFactory< std::string, Protocol, const LibUtilities::SessionReaderSharedPtr &, const TiXmlElement * > ProtocolFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: Protocol.h:54
StimulusFactory & Nektar::GetStimulusFactory ( )

Definition at line 45 of file Stimulus.cpp.

Referenced by Nektar::Stimulus::LoadStimuli().

46  {
47  typedef Loki::SingletonHolder<StimulusFactory,
48  Loki::CreateUsingNew,
49  Loki::NoDestroy > Type;
50  return Type::Instance();
51  }
LibUtilities::NekFactory< std::string, Stimulus, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr &, const TiXmlElement * > StimulusFactory
Datatype of the NekFactory used to instantiate classes derived from the EquationSystem class...
Definition: Stimulus.h:60
template<typename DataType >
std::vector<NekVector<DataType> > Nektar::GramSchmidtOrthogonalization ( const std::vector< NekVector< DataType > > &  x)

Calculates the orthogonal, normalized vectors from linearly independent input.

Returns
A list of ortogonalized vectors corresponding to the input vectors. If the size of the output doesn't match the size of the input then an error occurred. This algorithm is taken from "Parallel Scientific Computing in C++ and MPI", Karniadakis and Kirby, page 55.

Definition at line 54 of file NekLinAlgAlgorithms.hpp.

55  {
56  typedef NekVector<DataType> VectorType;
57  typedef NekMatrix<DataType> MatrixType;
58 
59  //typename dim = x[0].GetDimension();
60  unsigned int dim = x[0].GetDimension();
61  std::vector<VectorType> q(x.size(), VectorType());
62 
63  // This matrix holds the r_ij values. Using the matrix object
64  // is a convenience since it provides a 2D access to a table
65  // of values.
66  MatrixType r(dim, dim);
67  r(0,0) = x[0].L2Norm();
68 
69  if( r(0,0) == DataType(0) )
70  {
71  return q;
72  }
73 
74  q[0] = x[0]/r(0,0);
75 
76  for(unsigned int j = 1; j < x.size(); ++j)
77  {
78  for(unsigned int i = 0; i <= j-1; ++i)
79  {
80  r(i,j) = q[i].Dot(x[j]);
81  }
82 
83  VectorType y = x[j];
84  for(unsigned int i = 0; i <= j-1; ++i)
85  {
86  y = y - r(i,j)*q[i];
87  }
88 
89  r(j,j) = y.L2Norm();
90  if( r(j,j) == DataType(0) )
91  {
92  return q;
93  }
94 
95  q[j] = y/r(j,j);
96  }
97 
98  return q;
99  }
NekDouble Nektar::guessp ( NekDouble  g[],
NekDouble  rhoL,
NekDouble  uL,
NekDouble  pL,
NekDouble  cL,
NekDouble  rhoR,
NekDouble  uR,
NekDouble  pR,
NekDouble  cR 
)
inline

Use either PVRS, two-rarefaction or two-shock Riemann solvers to calculate an initial pressure for the Newton-Raphson scheme.

Parameters
gArray of calculated gamma values.
rhoLDensity left state.
rhoRDensity right state.
uLx-velocity component left state.
uRx-velocity component right state.
pLPressure component left state.
pRPressure component right state.
cLSound speed component left state.
cRSound speed component right state.
Returns
Computed initial guess for the Newton-Raphson scheme.

Definition at line 69 of file ExactSolverToro.cpp.

Referenced by Nektar::ExactSolverToro::v_PointSolve().

73  {
74  const NekDouble quser = 2.0;
75  NekDouble cup, ppv, pmin, pmax, qmax;
76 
77  cup = 0.25*(rhoL + rhoR)*(cL + cR);
78  ppv = 0.5 *(pL + pR) + 0.5*(uL - uR)*cup;
79  ppv = std::max(0.0, ppv);
80  pmin = std::min(pL, pR);
81  pmax = std::max(pL, pR);
82  qmax = pmax/pmin;
83 
84  if (qmax <= quser && pmin <= ppv && ppv <= pmax)
85  {
86  // Select PVRS Riemann solver.
87  return ppv;
88  }
89  else if (ppv < pmin)
90  {
91  // Select two-rarefaction Riemann solver.
92  NekDouble pq = pow(pL/pR, g[1]);
93  NekDouble um = (pq*uL/cL + uR/cR + g[4]*(pq - 1.0))/(pq/cL + 1.0/cR);
94  NekDouble ptL = 1.0 + g[7]*(uL - um)/cL;
95  NekDouble ptR = 1.0 + g[7]*(um - uR)/cR;
96  return 0.5*(pL*pow(ptL, g[3]) + pR*pow(ptR, g[3]));
97  }
98  else
99  {
100  // Select two-shock Riemann solver with PVRS as estimate.
101  NekDouble geL = sqrt((g[5]/rhoL)/(g[6]*pL + ppv));
102  NekDouble geR = sqrt((g[5]/rhoR)/(g[6]*pR + ppv));
103  return (geL*pL + geR*pR - (uR - uL))/(geL + geR);
104  }
105  }
double NekDouble
template<typename DataType >
DataType Nektar::InfinityNorm ( const NekVector< DataType > &  v)

Definition at line 932 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::InfinityNorm().

933  {
934  DataType result = fabs(v[0]);
935  const unsigned int vdim = v.GetDimension();
936  for(unsigned int i = 0; i < vdim; ++i)
937  {
938  result = std::max(fabs(v[i]), result);
939  }
940  return result;
941  }
template NekDouble Nektar::InfinityNorm ( const NekVector< NekDouble > &  v)
void Nektar::InvertInPlace ( NekDouble &  v)

Definition at line 1025 of file NekVector.cpp.

1025 { v = 1.0/v; }
bool Nektar::IsEqual ( const Array< OneD, const NekDouble > &  lhs,
const Array< OneD, const NekDouble > &  rhs,
NekDouble  tol 
)

Definition at line 45 of file ArrayEqualityComparison.cpp.

Referenced by operator==().

48  {
49  if( lhs.num_elements() != rhs.num_elements() )
50  {
51  return false;
52  }
53 
54  if( lhs.data() == rhs.data() )
55  {
56  return true;
57  }
58 
59  for(unsigned int i = 0; i < lhs.num_elements(); ++i)
60  {
61  if( fabs(lhs[i]-rhs[i]) > tol )
62  {
63  return false;
64  }
65  }
66 
67  return true;
68  }
StandardMatrixTag & lhs
bool Nektar::IsEqual ( const Array< TwoD, const NekDouble > &  lhs,
const Array< TwoD, const NekDouble > &  rhs,
NekDouble  tol 
)

Definition at line 76 of file ArrayEqualityComparison.cpp.

79  {
80  if( (lhs.GetRows() != rhs.GetRows()) ||
81  (lhs.GetColumns() != rhs.GetColumns()) )
82  {
83  return false;
84  }
85 
86  if( lhs.data() == rhs.data() )
87  {
88  return true;
89  }
90 
91  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
92  {
93  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
94  {
95  if( fabs(lhs[i][j]-rhs[i][j]) > tol )
96  {
97  return false;
98  }
99  }
100  }
101 
102  return true;
103  }
StandardMatrixTag & lhs
template<typename DataType >
DataType Nektar::L1Norm ( const NekVector< DataType > &  v)
Todo:
Do the Norms with Blas where applicable.

Definition at line 898 of file NekVector.cpp.

References Nektar::NekVector< DataType >::begin(), and Nektar::NekVector< DataType >::end().

Referenced by Nektar::NekVector< DataType >::L1Norm().

899  {
900  typedef NekVector<DataType> VectorType;
901 
902  DataType result(0);
903  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
904  {
905  result += fabs(*iter);
906  }
907 
908  return result;
909  }
template NekDouble Nektar::L1Norm ( const NekVector< NekDouble > &  v)
template<typename DataType >
DataType Nektar::L2Norm ( const NekVector< DataType > &  v)

Definition at line 915 of file NekVector.cpp.

References Nektar::NekVector< DataType >::begin(), and Nektar::NekVector< DataType >::end().

Referenced by Nektar::NekVector< DataType >::L2Norm().

916  {
917  typedef NekVector<DataType> VectorType;
918 
919  DataType result(0);
920  for(typename VectorType::const_iterator iter = v.begin(); iter != v.end(); ++iter)
921  {
922  DataType v = fabs(*iter);
923  result += v*v;
924  }
925  return sqrt(result);
926  }
template NekDouble Nektar::L2Norm ( const NekVector< NekDouble > &  v)
template<typename DataType >
DataType Nektar::Magnitude ( const NekVector< DataType > &  v)

Definition at line 976 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::Magnitude().

977  {
978  DataType result = DataType(0);
979 
980  const unsigned int vdim = v.GetDimension();
981  for(unsigned int i = 0; i < vdim; ++i)
982  {
983  result += v[i]*v[i];
984  }
985  return sqrt(result);
986  }
template NekDouble Nektar::Magnitude ( const NekVector< NekDouble > &  v)
template<typename DataType >
boost::shared_ptr<DataType> Nektar::MakePtr ( DataType *  d)

Definition at line 45 of file BoostUtil.hpp.

46  {
47  return boost::shared_ptr<DataType>(d);
48  }
DNekMat Nektar::MappingIdealToRef ( SpatialDomains::GeometrySharedPtr  geom)
inline

Definition at line 78 of file LinearElasticSystem.cpp.

References eFULL.

Referenced by Nektar::LinearElasticSystem::v_DoSolve().

79 {
80  int n = geom->GetNumVerts(), i, j;
81 
82  DNekMat map (n, n, 1.0, eFULL);
83  DNekMat mapref(n, n, 1.0, eFULL);
84 
85  // Extract coordinate information.
86  for (i = 0; i < n; ++i)
87  {
88  for (j = 0; j < n-1; ++j)
89  {
90  map(j,i) = (*geom->GetVertex(i))[j];
91  }
92  }
93 
94  // Set up reference triangle or tetrahedron mapping.
95  if (n == 3)
96  {
97  mapref(0,0) = -1.0; mapref(1,0) = -1.0;
98  mapref(0,1) = 1.0; mapref(1,1) = -1.0;
99  mapref(0,2) = -1.0; mapref(1,2) = 1.0;
100  }
101  else if (n == 4)
102  {
103  mapref(0,0) = -1.0; mapref(1,0) = -1.0; mapref(2,0) = -1.0;
104  mapref(0,1) = 1.0; mapref(1,1) = -1.0; mapref(2,1) = -1.0;
105  mapref(0,2) = -1.0; mapref(1,2) = 1.0; mapref(2,2) = -1.0;
106  mapref(0,3) = -1.0; mapref(1,3) = -1.0; mapref(2,3) = 1.0;
107  }
108 
109  map.Invert();
110 
111  DNekMat newmap = mapref * map;
112  DNekMat mapred(n-1, n-1, 1.0, eFULL);
113 
114  for (i = 0; i < n-1; ++i)
115  {
116  for (j = 0; j < n-1; ++j)
117  {
118  mapred(i,j) = newmap(i,j);
119  }
120  }
121 
122  return mapred;
123 }
NekMatrix< NekDouble, StandardMatrixTag > DNekMat
Definition: NekTypeDefs.hpp:52
template<typename ResultDataType , typename LhsDataType , typename LhsMatrixType >
void Nektar::Multiply ( NekMatrix< ResultDataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const ResultDataType &  rhs 
)

Definition at line 42 of file MatrixOperations.cpp.

References lhs.

Referenced by DiagonalBlockMatrixMultiply(), FullBlockMatrixMultiply(), and Multiply().

45  {
46  // TODO - optimize for the different matrix types.
47  int n = lhs.GetRows();
48  int m = lhs.GetColumns();
49  for(unsigned int i = 0; i < n; ++i)
50  {
51  for(unsigned int j = 0; j < m; ++j)
52  {
53  result(i,j) = lhs(i,j)*rhs;
54  }
55  }
56  }
StandardMatrixTag & lhs
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const DataType &  rhs 
)

Definition at line 62 of file MatrixOperations.cpp.

References Multiply().

64  {
65  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType ResultDataType;
66  NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
67  Multiply(result, lhs, rhs);
68  return result;
69  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< DataType > Nektar::Multiply ( const NekMatrix< LhsDataType, MatrixType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 443 of file MatrixVectorMultiplication.cpp.

References Multiply().

445  {
446  NekVector<DataType> result(lhs.GetRows(), DataType(0));
447  Multiply(result, lhs, rhs);
448  return result;
449  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::Multiply ( NekVector< DataType > &  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 410 of file MatrixVectorMultiplication.cpp.

References ASSERTL1, Nektar::NekVector< DataType >::GetRawPtr(), Nektar::NekVector< DataType >::GetRows(), lhs, and Multiply().

413  {
414 
415  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
416  boost::lexical_cast<std::string>(lhs.GetColumns()) +
417  std::string(" and a right side vector with row count ") +
418  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
419  Multiply(result.GetRawPtr(), lhs, rhs.GetRawPtr());
420  }
StandardMatrixTag & lhs
void Multiply(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
void Nektar::Multiply ( NekMatrix< ResultDataType, StandardMatrixTag > &  result,
const ResultDataType &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 74 of file MatrixOperations.cpp.

References Multiply().

78  {
79  Multiply(result, rhs, lhs);
80  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsInnerMatrixType >
void Nektar::Multiply ( NekVector< DataType > &  result,
const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 425 of file MatrixVectorMultiplication.cpp.

References DiagonalBlockMatrixMultiply(), eDIAGONAL, and FullBlockMatrixMultiply().

428  {
429  if( lhs.GetStorageType() == eDIAGONAL )
430  {
431  DiagonalBlockMatrixMultiply(result, lhs, rhs);
432  }
433  else
434  {
435  FullBlockMatrixMultiply(result, lhs, rhs);
436  }
437  }
void FullBlockMatrixMultiply(NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)
StandardMatrixTag & lhs
void DiagonalBlockMatrixMultiply(NekVector< double > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< double > &rhs)
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply ( const DataType &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 86 of file MatrixOperations.cpp.

References Multiply().

89  {
90  return Multiply(rhs, lhs);
91  }
StandardMatrixTag & lhs
void Multiply(NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename RhsDataType , typename DataType , typename LhsMatrixType , typename RhsMatrixType >
void Nektar::Multiply ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 146 of file MatrixOperations.cpp.

References ASSERTL1, eFULL, NekMultiplyDefaultImpl(), NekMultiplyFullMatrixFullMatrix(), and Nektar::NekMatrix< DataType, StandardMatrixTag >::SetSize().

149  {
150  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
151  boost::lexical_cast<std::string>(lhs.GetColumns()) +
152  std::string(" and a right side matrix with row count ") +
153  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
154 
155  result.SetSize(lhs.GetRows(), rhs.GetColumns());
156  if( lhs.GetType() == eFULL && rhs.GetType() == eFULL)
157  {
158  NekMultiplyFullMatrixFullMatrix(result, lhs, rhs);
159  }
160  else
161  {
162  NekMultiplyDefaultImpl(result, lhs, rhs);
163  }
164  }
void NekMultiplyFullMatrixFullMatrix(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
StandardMatrixTag & lhs
RhsMatrixType void NekMultiplyDefaultImpl(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix<typename boost::remove_const<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type, StandardMatrixTag> Nektar::Multiply ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 232 of file MatrixOperationsDeclarations.hpp.

References Multiply().

234  {
235  typedef typename boost::remove_const<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type NumberType;
236  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), rhs.GetColumns());
237  Multiply(result, lhs, rhs);
238  return result;
239  }
StandardMatrixTag & lhs
NekMatrix< typename boost::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Multiply(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::Multiply ( DataType *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const DataType *  rhs 
)

Definition at line 377 of file MatrixVectorMultiplication.cpp.

References eBANDED, eDIAGONAL, eFULL, eLOWER_TRIANGULAR, eLOWER_TRIANGULAR_BANDED, eSYMMETRIC, eSYMMETRIC_BANDED, eUPPER_TRIANGULAR, eUPPER_TRIANGULAR_BANDED, NekMultiplyBandedMatrix(), NekMultiplyDiagonalMatrix(), NekMultiplyFullMatrix(), NekMultiplyLowerTriangularMatrix(), NekMultiplyUnspecializedMatrixType(), and NekMultiplyUpperTriangularMatrix().

380  {
381  switch(lhs.GetType())
382  {
383  case eFULL:
384  NekMultiplyFullMatrix(result, lhs, rhs);
385  break;
386  case eDIAGONAL:
387  NekMultiplyDiagonalMatrix(result, lhs, rhs);
388  break;
389  case eUPPER_TRIANGULAR:
391  break;
392  case eLOWER_TRIANGULAR:
394  break;
395  case eSYMMETRIC:
397  break;
398  case eBANDED:
399  NekMultiplyBandedMatrix(result, lhs, rhs);
400  break;
401  case eSYMMETRIC_BANDED:
404  default:
406  }
407  }
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
void NekMultiplyFullMatrix(NekDouble *result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const NekDouble *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *p=0)
void NekMultiplyDiagonalMatrix(DataType *result, const NekMatrix< LhsDataType, StandardMatrixTag > &lhs, const DataType *rhs)
void NekMultiplyBandedMatrix(DataType *result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType *rhs, typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > > > >::type *p=0)
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename ResultDataType , typename InputDataType >
void Nektar::Multiply ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 657 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

660  {
661  ResultDataType* result_buf = result.GetRawPtr();
662  const InputDataType* rhs_buf = rhs.GetRawPtr();
663  const InputDataType* lhs_buf = lhs.GetRawPtr();
664  const unsigned int resdim = result.GetDimension();
665  for(int i = 0; i < resdim; ++i)
666  {
667  result_buf[i] = lhs_buf[i] * rhs_buf[i];
668  }
669  }
StandardMatrixTag & lhs
template void Nektar::Multiply ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename InputDataType >
NekVector< DataType > Nektar::Multiply ( const NekVector< DataType > &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 692 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Multiply().

694  {
695  NekVector<DataType> result(lhs.GetDimension());
696  Multiply(result, lhs, rhs);
697  return result;
698  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template NekVector<NekDouble> Nektar::Multiply ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename ResultDataType , typename InputDataType >
void Nektar::Multiply ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  lhs,
const NekDouble &  rhs 
)

Definition at line 706 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

709  {
710  ResultDataType* r_buf = result.GetRawPtr();
711  const InputDataType* lhs_buf = lhs.GetRawPtr();
712 
713  const unsigned int ldim = lhs.GetDimension();
714  for(int i = 0; i < ldim; ++i)
715  {
716  r_buf[i] = lhs_buf[i] * rhs;
717  }
718  }
StandardMatrixTag & lhs
template void Nektar::Multiply ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekDouble &  rhs 
)
template<typename DataType >
NekVector< DataType > Nektar::Multiply ( const NekVector< DataType > &  lhs,
const NekDouble &  rhs 
)

Definition at line 742 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Multiply().

744  {
745  NekVector<DataType> result(lhs.GetDimension());
746  Multiply(result, lhs, rhs);
747  return result;
748  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template NekVector<NekDouble> Nektar::Multiply ( const NekVector< NekDouble > &  lhs,
const NekDouble &  rhs 
)
template<typename ResultDataType , typename InputDataType >
void Nektar::Multiply ( NekVector< ResultDataType > &  result,
const NekDouble &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 756 of file NekVector.cpp.

References Multiply().

759  {
760  Multiply(result, rhs, lhs);
761  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template void Nektar::Multiply ( NekVector< NekDouble > &  result,
const NekDouble &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
NekVector< DataType > Nektar::Multiply ( const DataType &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 790 of file NekVector.cpp.

References Multiply().

792  {
793  return Multiply(rhs, lhs);
794  }
template NekVector< NekDouble > Multiply(const NekDouble &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template NekVector<NekDouble> Nektar::Multiply ( const NekDouble &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename LhsDataType >
void Nektar::MultiplyEqual ( NekMatrix< LhsDataType, StandardMatrixTag > &  lhs,
typename boost::call_traits< LhsDataType >::const_reference  rhs 
)
template<typename RhsInnerType , typename RhsMatrixType >
void Nektar::MultiplyEqual ( NekMatrix< double, StandardMatrixTag > &  result,
const NekMatrix< RhsInnerType, RhsMatrixType > &  rhs,
typename boost::enable_if< boost::mpl::and_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double >, CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > >::type *  t = 0 
)

Definition at line 157 of file MatrixOperationsDeclarations.hpp.

References ASSERTL0, and eFULL.

167  {
168  ASSERTL0(result.GetType() == eFULL && rhs.GetType() == eFULL, "Only full matrices supported.");
169  unsigned int M = result.GetRows();
170  unsigned int N = rhs.GetColumns();
171  unsigned int K = result.GetColumns();
172 
173  unsigned int LDA = M;
174  if( result.GetTransposeFlag() == 'T' )
175  {
176  LDA = K;
177  }
178 
179  unsigned int LDB = K;
180  if( rhs.GetTransposeFlag() == 'T' )
181  {
182  LDB = N;
183  }
184  double scale = rhs.Scale();
185  Array<OneD, double>& buf = result.GetTempSpace();
186  Blas::Dgemm(result.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
187  scale, result.GetRawPtr(), LDA, rhs.GetRawPtr(), LDB, 0.0,
188  buf.data(), result.GetRows());
189  result.SetSize(result.GetRows(), rhs.GetColumns());
190  result.SwapTempAndDataBuffers();
191  }
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:188
template<typename DataType , typename RhsInnerType , typename RhsMatrixType >
void Nektar::MultiplyEqual ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsInnerType, RhsMatrixType > &  rhs,
typename boost::enable_if< boost::mpl::or_< boost::mpl::not_< boost::is_same< typename RawType< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >::type, double > >, boost::mpl::not_< CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > > > > >::type *  t = 0 
)

Definition at line 194 of file MatrixOperationsDeclarations.hpp.

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

204  {
205  ASSERTL1(result.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
206  boost::lexical_cast<std::string>(result.GetColumns()) +
207  std::string(" and a right side matrix with row count ") +
208  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
209  NekMatrix<DataType, StandardMatrixTag> temp(result.GetRows(), result.GetColumns());
210 
211  for(unsigned int i = 0; i < result.GetRows(); ++i)
212  {
213  for(unsigned int j = 0; j < result.GetColumns(); ++j)
214  {
215  DataType t = DataType(0);
216 
217  // Set the result(i,j) element.
218  for(unsigned int k = 0; k < result.GetColumns(); ++k)
219  {
220  t += result(i,k)*rhs(k,j);
221  }
222  temp(i,j) = t;
223  }
224  }
225 
226  result = temp;
227  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename ResultDataType , typename InputDataType >
void Nektar::MultiplyEqual ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  rhs 
)

Definition at line 675 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

677  {
678  ResultDataType* result_buf = result.GetRawPtr();
679  const InputDataType* rhs_buf = rhs.GetRawPtr();
680  const unsigned int resdim = result.GetDimension();
681  for(int i = 0; i < resdim; ++i)
682  {
683  result_buf[i] *= rhs_buf[i];
684  }
685  }
template void Nektar::MultiplyEqual ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  rhs 
)
template<typename ResultDataType >
void Nektar::MultiplyEqual ( NekVector< ResultDataType > &  result,
const NekDouble &  rhs 
)

Definition at line 726 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

728  {
729  ResultDataType* r_buf = result.GetRawPtr();
730  const unsigned int rdim = result.GetDimension();
731  for(unsigned int i = 0; i < rdim; ++i)
732  {
733  r_buf[i] *= rhs;
734  }
735  }
template void Nektar::MultiplyEqual ( NekVector< NekDouble > &  result,
const NekDouble &  rhs 
)
template<typename ResultDataType , typename InputDataType >
void Nektar::MultiplyInvertedLhs ( NekVector< ResultDataType > &  result,
const NekDouble &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 764 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), Nektar::NekVector< DataType >::GetRawPtr(), and lhs.

767  {
768  ResultDataType* r_buf = result.GetRawPtr();
769  const InputDataType* rhs_buf = rhs.GetRawPtr();
770  NekDouble inverse = 1.0/lhs;
771 
772  const unsigned int rdim = rhs.GetDimension();
773  for(int i = 0; i < rdim; ++i)
774  {
775  r_buf[i] = inverse * rhs_buf[i];
776  }
777  }
StandardMatrixTag & lhs
double NekDouble
template void Nektar::MultiplyInvertedLhs ( NekVector< NekDouble > &  result,
const NekDouble &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
void Nektar::negate ( NekPoint< DataType > &  rhs)

Definition at line 373 of file NekPoint.hpp.

References Nektar::NekPoint< data_type >::negate().

374  {
375  rhs.negate();
376  }
template<typename DataType >
NekVector< DataType > Nektar::Negate ( const NekVector< DataType > &  v)

Definition at line 947 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension().

Referenced by Nektar::NekVector< DataType >::operator-().

948  {
949  NekVector<DataType> temp(v);
950  const unsigned int tdim = temp.GetDimension();
951  for(unsigned int i = 0; i < tdim; ++i)
952  {
953  temp(i) = -temp(i);
954  }
955  return temp;
956  }
template NekVector<NekDouble> Nektar::Negate ( const NekVector< NekDouble > &  v)
template<typename DataType >
void Nektar::NegateInPlace ( NekMatrix< DataType, ScaledMatrixTag > &  v)

Definition at line 247 of file ScaledMatrix.cpp.

248  {
249  v.SetScale(-1.0*v.Scale());
250  }
template void Nektar::NegateInPlace ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  v)
template<typename DataType >
void Nektar::NegateInPlace ( NekMatrix< DataType, StandardMatrixTag > &  m)

Definition at line 842 of file StandardMatrix.cpp.

References Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

843  {
844  for(unsigned int i = 0; i < m.GetRows(); ++i)
845  {
846  for(unsigned int j = 0; j < m.GetColumns(); ++j)
847  {
848  m(i,j) *= -1.0;
849  }
850  }
851  }
template void Nektar::NegateInPlace ( NekMatrix< double, StandardMatrixTag > &  v)
template<typename DataType >
void Nektar::NegateInPlace ( NekVector< DataType > &  v)

Definition at line 962 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::operator-().

963  {
964  DataType* data = v.GetRawPtr();
965  const unsigned int vdim = v.GetDimension();
966  for(unsigned int i = 0; i < vdim; ++i)
967  {
968  data[i] = -data[i];
969  }
970  }
template void Nektar::NegateInPlace ( NekVector< NekDouble > &  v)
void Nektar::NegateInPlace ( NekDouble &  v)

Definition at line 1024 of file NekVector.cpp.

1024 { v = -v; }
template<typename LhsDataType , typename MatrixType >
void Nektar::NekMultiplyBandedMatrix ( NekDouble *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const NekDouble *  rhs,
typename boost::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > > >::type *  p = 0 
)

Definition at line 101 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply().

108  {
109  int m = lhs.GetRows();
110  int n = lhs.GetColumns();
111  int kl = lhs.GetNumberOfSubDiagonals();
112  int ku = lhs.GetNumberOfSuperDiagonals();
113  double alpha = lhs.Scale();
114  const double* a = lhs.GetRawPtr();
115  int lda = kl + ku + 1;
116  const double* x = rhs;
117  int incx = 1;
118  double beta = 0.0;
119  double* y = result;
120  int incy = 1;
121  Blas::Dgbmv('N', m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy);
122 
123  }
StandardMatrixTag & lhs
template<typename DataType , typename LhsDataType >
void Nektar::NekMultiplyBandedMatrix ( DataType *  result,
const NekMatrix< LhsDataType, BlockMatrixTag > &  lhs,
const DataType *  rhs,
typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > > > >::type *  p = 0 
)

Definition at line 126 of file MatrixVectorMultiplication.cpp.

References ErrorUtil::efatal, and NEKERROR.

133  {
134  NEKERROR(ErrorUtil::efatal, "Banded block matrix multiplication not yet implemented");
135  }
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:185
RhsMatrixType void Nektar::NekMultiplyDefaultImpl ( NekMatrix< ResultType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 110 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Multiply(), and NekMultiplyFullMatrixFullMatrix().

113  {
114  ASSERTL1(lhs.GetColumns() == rhs.GetRows(), std::string("A left side matrix with column count ") +
115  boost::lexical_cast<std::string>(lhs.GetColumns()) +
116  std::string(" and a right side matrix with row count ") +
117  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be multiplied."));
118 
119  for(unsigned int i = 0; i < result.GetRows(); ++i)
120  {
121  for(unsigned int j = 0; j < result.GetColumns(); ++j)
122  {
123  ResultType t = ResultType(0);
124 
125  // Set the result(i,j) element.
126  for(unsigned int k = 0; k < lhs.GetColumns(); ++k)
127  {
128  t += lhs(i,k)*rhs(k,j);
129  }
130  result(i,j) = t;
131  }
132  }
133  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::NekMultiplyDiagonalMatrix ( DataType *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const DataType *  rhs 
)

Definition at line 79 of file MatrixVectorMultiplication.cpp.

References lhs.

Referenced by Multiply().

82  {
83  int n = lhs.GetRows();
84  for(unsigned int i = 0; i < n; ++i)
85  {
86  result[i] = lhs(i,i)*rhs[i];
87  }
88  }
StandardMatrixTag & lhs
template<typename DataType , typename LhsDataType >
void Nektar::NekMultiplyDiagonalMatrix ( DataType *  result,
const NekMatrix< LhsDataType, StandardMatrixTag > &  lhs,
const DataType *  rhs 
)

Definition at line 91 of file MatrixVectorMultiplication.cpp.

References Vmath::Vmul().

94  {
95  int n = lhs.GetRows();
96  const DataType* mat_ptr = lhs.GetRawPtr();
97  Vmath::Vmul(n, mat_ptr, 1, rhs, 1, result, 1);
98  }
StandardMatrixTag & lhs
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
template<typename InnerMatrixType , typename MatrixTag >
void Nektar::NekMultiplyFullMatrix ( NekDouble *  result,
const NekMatrix< InnerMatrixType, MatrixTag > &  lhs,
const NekDouble *  rhs,
typename boost::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > >::type *  p = 0 
)

Definition at line 339 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply().

344  {
345  int m = lhs.GetRows();
346  int n = lhs.GetColumns();
347 
348  char t = lhs.GetTransposeFlag();
349  if( t == 'T' )
350  {
351  std::swap(m, n);
352  }
353 
354  double alpha = lhs.Scale();
355  const double* a = lhs.GetRawPtr();
356  int lda = m;
357  const double* x = rhs;
358  int incx = 1;
359  double beta = 0.0;
360  double* y = result;
361  int incy = 1;
362 
363  Blas::Dgemv(t, m, n, alpha, a, lda, x, incx, beta, y, incy);
364  }
StandardMatrixTag & lhs
template<typename InnerMatrixType , typename MatrixTag >
void Nektar::NekMultiplyFullMatrix ( NekDouble *  result,
const NekMatrix< InnerMatrixType, MatrixTag > &  lhs,
const NekDouble *  rhs,
typename boost::enable_if< boost::mpl::not_< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > > > >::type *  p = 0 
)

Definition at line 367 of file MatrixVectorMultiplication.cpp.

References NekMultiplyUnspecializedMatrixType().

372  {
374  }
void NekMultiplyUnspecializedMatrixType(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void Nektar::NekMultiplyFullMatrixFullMatrix ( NekMatrix< NekDouble, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs,
typename boost::enable_if< boost::mpl::and_< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType > >, CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType > > > >::type *  p = 0 
)

Definition at line 112 of file MatrixOperationsDeclarations.hpp.

References ASSERTL1, and eFULL.

123  {
124  ASSERTL1(lhs.GetType() == eFULL && rhs.GetType() == eFULL, "Only full matrices are supported.");
125 
126  unsigned int M = lhs.GetRows();
127  unsigned int N = rhs.GetColumns();
128  unsigned int K = lhs.GetColumns();
129 
130  unsigned int LDA = M;
131  if( lhs.GetTransposeFlag() == 'T' )
132  {
133  LDA = K;
134  }
135 
136  unsigned int LDB = K;
137  if( rhs.GetTransposeFlag() == 'T' )
138  {
139  LDB = N;
140  }
141 
142  Blas::Dgemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
143  lhs.Scale()*rhs.Scale(), lhs.GetRawPtr(), LDA,
144  rhs.GetRawPtr(), LDB, 0.0,
145  result.GetRawPtr(), result.GetRows());
146  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
void Nektar::NekMultiplyFullMatrixFullMatrix ( NekMatrix< ResultType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 137 of file MatrixOperations.cpp.

References NekMultiplyDefaultImpl().

Referenced by Multiply().

140  {
141  NekMultiplyDefaultImpl(result, lhs, rhs);
142  }
StandardMatrixTag & lhs
RhsMatrixType void NekMultiplyDefaultImpl(NekMatrix< ResultType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
void Nektar::NekMultiplyLowerTriangularMatrix ( NekDouble *  result,
const NekMatrix< NekDouble, StandardMatrixTag > &  lhs,
const NekDouble *  rhs 
)

Definition at line 254 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply(), and NekMultiplyLowerTriangularMatrix().

257  {
258  int vectorSize = lhs.GetColumns();
259  std::copy(rhs, rhs+vectorSize, result);
260  int n = lhs.GetRows();
261  const double* a = lhs.GetRawPtr();
262  double* x = result;
263  int incx = 1;
264 
265  Blas::Dtpmv('L', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
266  }
StandardMatrixTag & lhs
void Nektar::NekMultiplyLowerTriangularMatrix ( NekDouble *  result,
const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  lhs,
const NekDouble *  rhs 
)

Definition at line 268 of file MatrixVectorMultiplication.cpp.

References lhs, and NekMultiplyLowerTriangularMatrix().

271  {
272  NekMultiplyLowerTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
273 
274  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
275  {
276  result[i] *= lhs.Scale();
277  }
278  }
void NekMultiplyLowerTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
StandardMatrixTag & lhs
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::NekMultiplyLowerTriangularMatrix ( DataType *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const DataType *  rhs 
)

Definition at line 281 of file MatrixVectorMultiplication.cpp.

References lhs.

284  {
285  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
286  {
287  DataType accum = DataType(0);
288  for(unsigned int j = 0; j <= i; ++j)
289  {
290  accum += lhs(i,j)*rhs[j];
291  }
292  result[i] = accum;
293  }
294  }
StandardMatrixTag & lhs
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::NekMultiplyUnspecializedMatrixType ( DataType *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const DataType *  rhs 
)

Definition at line 63 of file MatrixVectorMultiplication.cpp.

References lhs.

Referenced by Multiply(), and NekMultiplyFullMatrix().

66  {
67  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
68  {
69  DataType accum = DataType(0);
70  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
71  {
72  accum += lhs(i,j)*rhs[j];
73  }
74  result[i] = accum;
75  }
76  }
StandardMatrixTag & lhs
void Nektar::NekMultiplyUpperTriangularMatrix ( NekDouble *  result,
const NekMatrix< NekDouble, StandardMatrixTag > &  lhs,
const NekDouble *  rhs 
)

Definition at line 296 of file MatrixVectorMultiplication.cpp.

Referenced by Multiply(), and NekMultiplyUpperTriangularMatrix().

299  {
300  int vectorSize = lhs.GetColumns();
301  std::copy(rhs, rhs+vectorSize, result);
302  int n = lhs.GetRows();
303  const double* a = lhs.GetRawPtr();
304  double* x = result;
305  int incx = 1;
306 
307  Blas::Dtpmv('U', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
308  }
StandardMatrixTag & lhs
void Nektar::NekMultiplyUpperTriangularMatrix ( NekDouble *  result,
const NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  lhs,
const NekDouble *  rhs 
)

Definition at line 310 of file MatrixVectorMultiplication.cpp.

References lhs, and NekMultiplyUpperTriangularMatrix().

313  {
314  NekMultiplyUpperTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
315 
316  for(unsigned int i = 0; i < lhs.GetColumns(); ++i)
317  {
318  result[i] *= lhs.Scale();
319  }
320  }
StandardMatrixTag & lhs
void NekMultiplyUpperTriangularMatrix(DataType *result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType *rhs)
template<typename DataType , typename LhsDataType , typename MatrixType >
void Nektar::NekMultiplyUpperTriangularMatrix ( DataType *  result,
const NekMatrix< LhsDataType, MatrixType > &  lhs,
const DataType *  rhs 
)

Definition at line 323 of file MatrixVectorMultiplication.cpp.

References lhs.

326  {
327  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
328  {
329  DataType accum = DataType(0);
330  for(unsigned int j = i; j < lhs.GetColumns(); ++j)
331  {
332  accum += lhs(i,j)*rhs[j];
333  }
334  result[i] = accum;
335  }
336  }
StandardMatrixTag & lhs
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(1,(const NekDouble &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(DNekMat))  ,
(0,())  ,
(1,(const NekDouble &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(2,(DNekMat &, const NekDouble &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(DNekMat))  ,
(1,(const NekDouble &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( MultiplyEqual  ,
(1,(DNekMat &))  ,
(1,(void))  ,
(0,())  ,
(1,(const NekDouble &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( AddEqual  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( SubtractEqual  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_STANDARD_AND_SCALED_MATRICES  ,
(1,(void))  ,
(1,(NekVector< NekDouble > &))  ,
(1,(const NekVector< NekDouble > &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_BLOCK_MATRIX_TYPES  ,
(1,(void))  ,
(1,(NekVector< NekDouble > &))  ,
(1,(const NekVector< NekDouble > &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(NekVector< NekDouble >))  ,
(0,())  ,
(1,(const NekVector< NekDouble > &))   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES ( Multiply  ,
NEKTAR_ALL_MATRIX_TYPES  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES ( Add  ,
NEKTAR_ALL_MATRIX_TYPES  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES ( Add  ,
NEKTAR_ALL_MATRIX_TYPES  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(DNekMat))  ,
(0,())  ,
(0,())   
)
Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES ( Subtract  ,
NEKTAR_ALL_MATRIX_TYPES  ,
NEKTAR_ALL_MATRIX_TYPES  ,
(1,(void))  ,
(1,(DNekMat &))  ,
(0,())   
)
template<typename DataType >
void Nektar::Normalize ( NekVector< DataType > &  v)

Definition at line 1012 of file NekVector.cpp.

References Nektar::NekVector< DataType >::Magnitude().

Referenced by Nektar::NekVector< DataType >::Normalize().

1013  {
1014  DataType m = v.Magnitude();
1015  if( m > DataType(0) )
1016  {
1017  v /= m;
1018  }
1019  }
template void Nektar::Normalize ( NekVector< NekDouble > &  v)
template<typename DataType >
bool Nektar::operator!= ( const MemoryManager< DataType > &  lhs,
const MemoryManager< DataType > &  rhs 
)

Definition at line 384 of file NekMemoryManager.hpp.

385  {
386  return !(lhs == rhs);
387  }
StandardMatrixTag & lhs
template<typename T1 , typename T2 >
bool Nektar::operator!= ( const Array< OneD, T1 > &  lhs,
const Array< OneD, T2 > &  rhs 
)

Definition at line 738 of file SharedArray.hpp.

739  {
740  return !(lhs == rhs);
741  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator!= ( const Array< TwoD, DataType > &  lhs,
const Array< TwoD, DataType > &  rhs 
)

Definition at line 799 of file SharedArray.hpp.

800  {
801  return !(lhs == rhs);
802  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator!= ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 862 of file NekVector.cpp.

864  {
865  return !(lhs == rhs);
866  }
StandardMatrixTag & lhs
template bool Nektar::operator!= ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint<DataType> Nektar::operator* ( const ScalarType &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 434 of file NekPoint.hpp.

References lhs.

435  {
436  NekPoint<DataType> result(rhs);
437  result *= lhs;
438  return result;
439  }
StandardMatrixTag & lhs
template<typename DataType , typename dim , typename space , typename ScalarType >
NekPoint<DataType> Nektar::operator* ( const NekPoint< DataType > &  lhs,
const ScalarType &  rhs 
)

Definition at line 443 of file NekPoint.hpp.

444  {
445  NekPoint<DataType> result(lhs);
446  result *= rhs;
447  return result;
448  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator+ ( const NekPoint< DataType > &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 380 of file NekPoint.hpp.

381  {
382  NekPoint<DataType> result(lhs);
383  result += rhs;
384  return result;
385  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator+ ( typename boost::call_traits< DataType >::const_reference  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 389 of file NekPoint.hpp.

References lhs.

390  {
391  NekPoint<DataType> result(rhs);
392  result += lhs;
393  return result;
394  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator+ ( const NekPoint< DataType > &  lhs,
typename boost::call_traits< DataType >::const_reference  rhs 
)

Definition at line 398 of file NekPoint.hpp.

399  {
400  NekPoint<DataType> result(lhs);
401  result += rhs;
402  return result;
403  }
StandardMatrixTag & lhs
template<typename DataType >
Array<OneD, DataType> Nektar::operator+ ( const Array< OneD, DataType > &  lhs,
unsigned int  offset 
)

Definition at line 744 of file SharedArray.hpp.

745  {
746  return Array<OneD, const DataType>::CreateWithOffset(lhs, offset);
747  }
StandardMatrixTag & lhs
template<typename DataType >
Array<OneD, DataType> Nektar::operator+ ( unsigned int  offset,
const Array< OneD, DataType > &  rhs 
)

Definition at line 750 of file SharedArray.hpp.

751  {
752  return Array<OneD, const DataType>::CreateWithOffset(rhs, offset);
753  }
template<typename DataType >
NekPoint<DataType> Nektar::operator- ( const NekPoint< DataType > &  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 407 of file NekPoint.hpp.

408  {
409  NekPoint<DataType> result(lhs);
410  result -= rhs;
411  return result;
412  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator- ( typename boost::call_traits< DataType >::const_reference  lhs,
const NekPoint< DataType > &  rhs 
)

Definition at line 416 of file NekPoint.hpp.

References lhs.

417  {
418  NekPoint<DataType> result(-rhs);
419  result += lhs;
420  return result;
421  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator- ( const NekPoint< DataType > &  lhs,
typename boost::call_traits< DataType >::const_reference  rhs 
)

Definition at line 425 of file NekPoint.hpp.

426  {
427  NekPoint<DataType> result(lhs);
428  result -= rhs;
429  return result;
430  }
StandardMatrixTag & lhs
template<typename DataType >
NekPoint<DataType> Nektar::operator/ ( const NekPoint< DataType > &  lhs,
typename boost::call_traits< DataType >::param_type  rhs 
)

Definition at line 452 of file NekPoint.hpp.

453  {
454  NekPoint<DataType> result(lhs);
455  result /= rhs;
456  return result;
457  }
StandardMatrixTag & lhs
template<typename DataType , typename FormType >
std::ostream& Nektar::operator<< ( std::ostream &  os,
const NekMatrix< DataType, FormType > &  rhs 
)

Definition at line 56 of file NekMatrix.hpp.

57  {
58  int oswidth = 9;
59  int osprecision = 6;
60 
61  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
62  {
63  os << "[";
64  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
65  {
66  os.width(oswidth);
67  os.precision(osprecision);
68  os << rhs(i,j);
69  if( j != rhs.GetColumns() - 1 )
70  {
71  os << ", ";
72  }
73  }
74  os << "]";
75  if( i != rhs.GetRows()-1 )
76  {
77  os << std::endl;
78  }
79  }
80  return os;
81  }
template<typename SparseStorageType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekSparseMatrix< SparseStorageType > &  rhs 
)

Definition at line 87 of file SparseUtils.cpp.

88  {
89  int oswidth = 9;
90  int osprecision = 6;
91 
92  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
93  {
94  os << "[";
95  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
96  {
97  os.width(oswidth);
98  os.precision(osprecision);
99  os << rhs(i,j);
100  if( j != rhs.GetColumns() - 1 )
101  {
102  os << ", ";
103  }
104  }
105  os << "]";
106  if( i != rhs.GetRows()-1 )
107  {
108  os << std::endl;
109  }
110  }
111  return os;
112  }
template<typename SparseStorageType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekSparseDiagBlkMatrix< SparseStorageType > &  rhs 
)

Definition at line 115 of file SparseUtils.cpp.

116  {
117  int oswidth = 9;
118  int osprecision = 6;
119 
120  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
121  {
122  os << "[";
123  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
124  {
125  os.width(oswidth);
126  os.precision(osprecision);
127  os << rhs(i,j);
128  if( j != rhs.GetColumns() - 1 )
129  {
130  os << ", ";
131  }
132  }
133  os << "]";
134  if( i != rhs.GetRows()-1 )
135  {
136  os << std::endl;
137  }
138  }
139  return os;
140  }
template std::ostream& Nektar::operator<< ( std::ostream &  os,
const NekSparseMatrix< StorageSmvBsr< NekDouble > > &  rhs 
)
template std::ostream& Nektar::operator<< ( std::ostream &  os,
const NekSparseDiagBlkMatrix< StorageSmvBsr< NekDouble > > &  rhs 
)
template<typename DataType >
std::ostream& Nektar::operator<< ( std::ostream &  os,
const NekPoint< DataType > &  p 
)

Definition at line 496 of file NekPoint.hpp.

References Nektar::NekPoint< data_type >::AsString().

497  {
498  os << p.AsString();
499  return os;
500  }
template<typename DataType >
std::ostream & Nektar::operator<< ( std::ostream &  os,
const NekVector< DataType > &  rhs 
)

Definition at line 802 of file NekVector.cpp.

803  {
804  os << rhs.AsString();
805  return os;
806  }
template std::ostream& Nektar::operator<< ( std::ostream &  os,
const NekVector< NekDouble > &  rhs 
)
bool Nektar::operator== ( const Array< OneD, NekDouble > &  lhs,
const Array< OneD, NekDouble > &  rhs 
)

Definition at line 39 of file ArrayEqualityComparison.cpp.

References IsEqual().

40  {
41  return IsEqual(lhs,rhs);
42  }
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
bool Nektar::operator== ( const Array< TwoD, NekDouble > &  lhs,
const Array< TwoD, NekDouble > &  rhs 
)

Definition at line 71 of file ArrayEqualityComparison.cpp.

References IsEqual().

72  {
73  return IsEqual(lhs,rhs);
74  }
StandardMatrixTag & lhs
bool IsEqual(const Array< TwoD, const NekDouble > &lhs, const Array< TwoD, const NekDouble > &rhs, NekDouble tol)
template<typename DataType >
bool Nektar::operator== ( const MemoryManager< DataType > &  lhs,
const MemoryManager< DataType > &  rhs 
)

Definition at line 378 of file NekMemoryManager.hpp.

379  {
380  return true;
381  }
template<typename T1 , typename T2 >
bool Nektar::operator== ( const Array< OneD, T1 > &  lhs,
const Array< OneD, T2 > &  rhs 
)

Definition at line 714 of file SharedArray.hpp.

715  {
716  if( lhs.num_elements() != rhs.num_elements() )
717  {
718  return false;
719  }
720 
721  if( lhs.data() == rhs.data() )
722  {
723  return true;
724  }
725 
726  for(unsigned int i = 0; i < lhs.num_elements(); ++i)
727  {
728  if( lhs[i] != rhs[i] )
729  {
730  return false;
731  }
732  }
733 
734  return true;
735  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator== ( const Array< TwoD, DataType > &  lhs,
const Array< TwoD, DataType > &  rhs 
)

Definition at line 793 of file SharedArray.hpp.

References Nektar::Array< TwoD, const DataType >::m_data.

794  {
795  return *lhs.m_data == *rhs.m_data;
796  }
StandardMatrixTag & lhs
template<typename DataType >
bool Nektar::operator== ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 846 of file NekVector.cpp.

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), and Nektar::NekVector< DataType >::GetDimension().

848  {
849  if( lhs.GetDimension() != rhs.GetDimension() )
850  {
851  return false;
852  }
853 
854  return std::equal(lhs.begin(), lhs.end(), rhs.begin());
855  }
StandardMatrixTag & lhs
template bool Nektar::operator== ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename FormType >
std::ostream& Nektar::operator>> ( std::ostream &  os,
const NekMatrix< DataType, FormType > &  rhs 
)

Definition at line 84 of file NekMatrix.hpp.

85  {
86  NekDouble tol = 1e-12;
87  os << "[" << std::endl;
88 
89  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
90  {
91  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
92  {
93  if((NekDouble)rhs(i,j) > tol)
94  {
95  os << '+';
96  }
97  else if((NekDouble)rhs(i,j) < -tol)
98  {
99  os << '*';
100  }
101  else
102  {
103  os << '-';
104  }
105  }
106  if( i != rhs.GetRows()-1 )
107  {
108  os << std::endl;
109  }
110  }
111  os << "]" << std::endl;
112  return os;
113  }
double NekDouble
void Nektar::prefun ( NekDouble *  g,
NekDouble  p,
NekDouble  dk,
NekDouble  pk,
NekDouble  ck,
NekDouble &  f,
NekDouble &  fd 
)
inline

Evaluate pressure functions fL and fR in Newton iteration of Riemann solver (see equation 4.85 and 4.86 of Toro 2009).

Parameters
gArray of gamma parameters.
pPressure at current iteration.
dkDensity (left or right state)
pkPressure (left or right state)
ckSound speed (left or right state)
fComputed pressure (shock).
fdComputed pressure (rarefaction).

Definition at line 119 of file ExactSolverToro.cpp.

Referenced by Nektar::ExactSolverToro::v_PointSolve().

121  {
122  if (p <= pk)
123  {
124  // Rarefaction wave
125  NekDouble prat = p/pk;
126  f = g[4]*ck*(pow(prat, g[1])-1.0);
127  fd = pow(prat, -g[2])/(dk*ck);
128  }
129  else
130  {
131  // Shock wave
132  NekDouble ak = g[5]/dk;
133  NekDouble bk = g[6]*pk;
134  NekDouble qrt = sqrt(ak/(bk+p));
135  f = (p-pk)*qrt;
136  fd = (1.0-0.5*(p-pk)/(bk+p))*qrt;
137  }
138  }
double NekDouble
void Nektar::Subtract ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 273 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

Referenced by Subtract().

276  {
277  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
278  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
279  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
280  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
281  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
282  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
283 
284  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
285  {
286  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
287  {
288  result(i,j) = lhs(i,j) - rhs(i,j);
289  }
290  }
291  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Subtract ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 364 of file MatrixOperations.cpp.

References Subtract().

366  {
367  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
368  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
369  Subtract(result, lhs, rhs);
370  return result;
371  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
DNekMat NekMatrix<typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType, StandardMatrixTag> Nektar::Subtract ( const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 364 of file MatrixOperations.cpp.

References Subtract().

366  {
367  typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
368  NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(), lhs.GetColumns());
369  Subtract(result, lhs, rhs);
370  return result;
371  }
StandardMatrixTag & lhs
DNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Subtract(const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)
template<typename ResultDataType , typename InputDataType >
void Nektar::Subtract ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 515 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

518  {
519  ResultDataType* r_buf = result.GetRawPtr();
520  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
521  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
522  const unsigned int ldim = lhs.GetDimension();
523  for(int i = 0; i < ldim; ++i)
524  {
525  r_buf[i] = lhs_buf[i] - rhs_buf[i];
526  }
527  }
StandardMatrixTag & lhs
template void Nektar::Subtract ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
NekVector< DataType > Nektar::Subtract ( const NekVector< DataType > &  lhs,
const NekVector< DataType > &  rhs 
)

Definition at line 590 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Subtract().

592  {
593  NekVector<DataType> result(lhs.GetDimension());
594  Subtract(result, lhs, rhs);
595  return result;
596  }
template NekVector< NekDouble > Subtract(const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)
StandardMatrixTag & lhs
template NekVector<NekDouble> Nektar::Subtract ( const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void Nektar::SubtractEqual ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 320 of file MatrixOperations.cpp.

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator-=().

322  {
323  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
324  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
325  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
326  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
327  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
328  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
329 
330  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
331  {
332  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
333  {
334  result(i,j) -= rhs(i,j);
335  }
336  }
337  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
DNekMat void Nektar::SubtractEqual ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 320 of file MatrixOperations.cpp.

References ASSERTL1.

Referenced by Nektar::NekVector< DataType >::operator-=().

322  {
323  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
324  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
325  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
326  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
327  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
328  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
329 
330  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
331  {
332  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
333  {
334  result(i,j) -= rhs(i,j);
335  }
336  }
337  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename ResultDataType , typename InputDataType >
void Nektar::SubtractEqual ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  rhs 
)

Definition at line 555 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

557  {
558  ResultDataType* r_buf = result.GetRawPtr();
559  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
560  const unsigned int rdim = rhs.GetDimension();
561  for(int i = 0; i < rdim; ++i)
562  {
563  r_buf[i] -= rhs_buf[i];
564  }
565  }
template void Nektar::SubtractEqual ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void Nektar::SubtractEqualNegatedLhs ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 340 of file MatrixOperations.cpp.

References ASSERTL1, Nektar::ConstMatrix< DataType >::GetColumns(), and Nektar::ConstMatrix< DataType >::GetRows().

342  {
343  ASSERTL1(result.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
344  boost::lexical_cast<std::string>(result.GetRows()) + std::string(" and ") +
345  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
346  ASSERTL1(result.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
347  boost::lexical_cast<std::string>(result.GetColumns()) + std::string(" and ") +
348  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
349 
350  for(unsigned int i = 0; i < rhs.GetRows(); ++i)
351  {
352  for(unsigned int j = 0; j < rhs.GetColumns(); ++j)
353  {
354  result(i,j) = -result(i,j) - rhs(i,j);
355  }
356  }
357  }
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename ResultDataType , typename InputDataType >
void Nektar::SubtractEqualNegatedLhs ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  rhs 
)

Definition at line 568 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

570  {
571  ResultDataType* r_buf = result.GetRawPtr();
572  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
573  const unsigned int rdim = rhs.GetDimension();
574  for(int i = 0; i < rdim; ++i)
575  {
576  r_buf[i] = -r_buf[i] - rhs_buf[i];
577  }
578  }
template void Nektar::SubtractEqualNegatedLhs ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
void Nektar::SubtractNegatedLhs ( NekMatrix< DataType, StandardMatrixTag > &  result,
const NekMatrix< LhsDataType, LhsMatrixType > &  lhs,
const NekMatrix< RhsDataType, RhsMatrixType > &  rhs 
)

Definition at line 294 of file MatrixOperations.cpp.

References ASSERTL1, and lhs.

297  {
298  ASSERTL1(lhs.GetRows() == rhs.GetRows(), std::string("Matrices with different row counts ") +
299  boost::lexical_cast<std::string>(lhs.GetRows()) + std::string(" and ") +
300  boost::lexical_cast<std::string>(rhs.GetRows()) + std::string(" can't be subtracted."));
301  ASSERTL1(lhs.GetColumns() == rhs.GetColumns(), std::string("Matrices with different column counts ") +
302  boost::lexical_cast<std::string>(lhs.GetColumns()) + std::string(" and ") +
303  boost::lexical_cast<std::string>(rhs.GetColumns()) + std::string(" can't be subtracted."));
304 
305  for(unsigned int i = 0; i < lhs.GetRows(); ++i)
306  {
307  for(unsigned int j = 0; j < lhs.GetColumns(); ++j)
308  {
309  result(i,j) = -lhs(i,j) - rhs(i,j);
310  }
311  }
312  }
StandardMatrixTag & lhs
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:218
template<typename ResultDataType , typename InputDataType >
void Nektar::SubtractNegatedLhs ( NekVector< ResultDataType > &  result,
const NekVector< InputDataType > &  lhs,
const NekVector< InputDataType > &  rhs 
)

Definition at line 530 of file NekVector.cpp.

References Nektar::NekVector< DataType >::GetDimension(), and Nektar::NekVector< DataType >::GetRawPtr().

533  {
534  ResultDataType* r_buf = result.GetRawPtr();
535  typename boost::add_const<InputDataType>::type* lhs_buf = lhs.GetRawPtr();
536  typename boost::add_const<InputDataType>::type* rhs_buf = rhs.GetRawPtr();
537  const unsigned int ldim = lhs.GetDimension();
538  for(int i = 0; i < ldim; ++i)
539  {
540  r_buf[i] = -lhs_buf[i] - rhs_buf[i];
541  }
542  }
StandardMatrixTag & lhs
template void Nektar::SubtractNegatedLhs ( NekVector< NekDouble > &  result,
const NekVector< NekDouble > &  lhs,
const NekVector< NekDouble > &  rhs 
)
template<typename DataType >
NekMatrix< DataType, ScaledMatrixTag > Nektar::Transpose ( NekMatrix< DataType, ScaledMatrixTag > &  rhs)

Definition at line 187 of file ScaledMatrix.cpp.

188  {
189  NekMatrix<DataType, ScaledMatrixTag> result(rhs);
190  result.Transpose();
191  return result;
192  }
template<typename InnerMatrixType >
NekMatrix<InnerMatrixType, BlockMatrixTag> Nektar::Transpose ( NekMatrix< InnerMatrixType, BlockMatrixTag > &  rhs)
template NekMatrix< NekMatrix<NekDouble, StandardMatrixTag>, ScaledMatrixTag> Nektar::Transpose ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > &  rhs)
template<typename DataType >
NekMatrix< DataType, StandardMatrixTag > Nektar::Transpose ( NekMatrix< DataType, StandardMatrixTag > &  rhs)