Namespaces
namespace	BandedMatrixMatrixMultiplicationTests

namespace	BandedMatrixStoragePolicyUnitTests

namespace	BandedMatrixVectorMultiplicationUnitTests

namespace	BlockMatrixUnitTests

namespace	Collections

namespace	ConsistentObjectAccessUnitTests

namespace	detail

namespace	DiagonalMatrixOperationsUnitTests

namespace	DiagonalMatrixStoragePolicyUnitTests

namespace	Expansion3DTests

namespace	FieldUtils

namespace	FullMatrixOperationsUnitTests

namespace	FullMatrixStoragePolicyUnitTests

namespace	GlobalMapping

namespace	HexCollectionTests
	The above copyright notice and this permission notice shall be included.

namespace	HexExpTests

namespace	InterpreterUnitTests

namespace	LibUtilities

namespace	LinearSystemUnitTests

namespace	LocalRegions

namespace	LowerTriangularMatrixUnitTests

namespace	LowerTriangularStoragePolicyUnitTests

namespace	MatrixMultiplicationTests

namespace	MatrixOperationTests

namespace	MatrixSubtractionTests

namespace	MatrixUnitTests

namespace	MemManagerUnitTests

namespace	MovementTests

namespace	MultiRegions

namespace	NekConstants

namespace	NekMeshTetrahedronUnitTest
	The above copyright notice and this permission notice shall be included.

namespace	PrismCollectionTests

namespace	PyrCollectionTests

namespace	QuadCollectionTests

namespace	RealComparisonUnitTests

namespace	RiemannTests
	The above copyright notice and this permission notice shall be included.

namespace	ScaledBlockMatrixUnitTests

namespace	ScaledMatrixUnitTests

namespace	SegCollectionTests

namespace	SharedArrayUnitTests

namespace	SimdLibTests

namespace	SolverUtils

namespace	SpatialDomains

namespace	StandardMatrixOperationsUnitTests

namespace	StandardMatrixUnitTests

namespace	StdRegions

namespace	SymmetricMatrixStoragePolicyUnitTests

namespace	TetCollectionTests
	The above copyright notice and this permission notice shall be included.

namespace	Thread

namespace	TriangularMatrixVectorMultiplicationUnitTests

namespace	TriCollectionTests

namespace	UnitTests

namespace	UpperTriangularMatrixUnitTests

namespace	UpperTriangularUnitTests

namespace	VarcoeffHashingTest

namespace	VariableSizedNekVectorUnitTests

namespace	VmathSIMDUnitTests

Classes
class	AcousticSolver

class	AcousticSystem

class	AdjointAdvection
	Advection for the adjoint form of the linearised Navier-Stokes equations. More...

class	AInflow

class	AlternateSkewAdvection

class	APE

class	APELaxFriedrichsSolver

class	APEUpwindSolver

class	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< TwoD, const DataType >
	2D array with garbage collection and bounds checking. More...

class	Array< TwoD, DataType >
	A 2D array. More...

class	ArrayDestructionPolicy

class	ArrayDestructionPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >

class	ArrayDestructionPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >

class	ArrayInitializationPolicy

class	ArrayInitializationPolicy< ObjectType, typename std::enable_if< std::is_fundamental< ObjectType >::value >::type >

class	ArrayInitializationPolicy< ObjectType, typename std::enable_if<!std::is_fundamental< ObjectType >::value >::type >

class	ArtificialDiffusion
	Encapsulates the artificial diffusion used in shock capture. More...

class	AUSM0Solver

class	AUSM1Solver

class	AUSM2Solver

class	AUSM3Solver

class	AverageSolver

struct	BandedMatrixFuncs

class	BetaPressureArea

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	CFSBndCond
	Encapsulates the user-defined boundary conditions for compressible flow solver. More...

class	CFSImplicit

struct	Command

class	CompressibleFlowSystem

class	CompressibleSolver

struct	ConsistentObjectAccess

struct	ConsistentObjectAccess< DataType * >

struct	ConsistentObjectAccess< std::shared_ptr< DataType > >

class	ConstMatrix

class	CountedObject

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	DependentFile

struct	DiagonalMatrixFuncs

class	DiffusionLDGNS

class	Dummy

class	EigenValuesAdvection

class	EmpiricalPressureArea

class	EnforceEntropyPressure
	Outflow characteristic boundary conditions for compressible flow problems. More...

class	EnforceEntropyTotalEnthalpy
	Outflow characteristic boundary conditions for compressible flow problems. More...

class	EnforceEntropyVelocity
	Outflow characteristic boundary conditions for compressible flow problems. More...

struct	EnumHash

class	EquationOfState
	Encapsulates equations of state allowing us to obtain thermodynamic properties: most relations are in the form X(rho,e) More...

class	ErrorUtil

class	EulerCFE

class	EulerImplicitCFE

class	ExactSolverToro

class	Extrapolate

class	ExtrapOrder0BC
	Extrapolation of order 0 for all the variables such that, at the boundaries, a trivial Riemann problem is solved. More...

class	FentonKarma

class	FilterAeroForcesSPM

class	FilterBenchmark
	Records activation and repolarisation times. More...

class	FilterCellHistoryPoints

class	FilterCheckpointCellModel

class	FilterElectrogram

class	FilterHilbertFFTPhase

class	FilterMovingBody

class	FilterOffsetPhase

class	FlagList
	Defines a list of flags. More...

class	ForcingAxiSymmetric

class	ForcingMovingBody

class	ForcingQuasi1D

class	ForcingStabilityCoupledLNS

struct	FourD

class	Fox02

struct	FullMatrixFuncs

class	Helmholtz

struct	HighOrderOutflow

class	HLLCSolver

class	HLLSolver

class	IdealGasEoS
	Ideal gas equation of state: p = rho * R * T. More...

class	ImageWarpingSystem

class	ImplicitExtrapolate

class	IncBaseCondition

class	IncBoundaryConditions

class	IncNavierStokes
	This class is the base class for Navier Stokes problems. More...

struct	InterfacePoint

class	IsentropicVortexBC
	Wall boundary conditions for compressible flow problems. More...

struct	IsSharedPointer

struct	IsSharedPointer< std::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	LEE

class	LEELaxFriedrichsSolver

class	LEESolver

class	LEEUpwindSolver

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	MappingExtrapolate

class	Matrix

class	MemoryManager
	General purpose memory allocation routines with the ability to allocate from thread specific memory pools. More...

class	MemPool

class	Metric
	Base class for all metrics. Metric represents a test metric that can be used to evaluate the functionality or performance of a Nektar++ executable. More...

class	MetricEigenvalue

class	MetricExecutionTime
	Metric that finds the execution time in an output and tests it against an accepted value and tolerance. More...

struct	MetricExecutionTimeFieldValue
	Data structure for an execution time field value. More...

class	MetricFactory
	Datatype of the NekFactory used to instantiate classes derived from the Advection class. More...

class	MetricFile

class	MetricFileExists

class	MetricL2

class	MetricLInf

class	MetricNoWarning

class	MetricPrecon

class	MetricPyUnitTest

class	MetricRegex

struct	MetricRegexFieldValue
	Data structure for a Regex value to match. More...

class	MMFAdvection

class	MMFDiffusion
	A model for cardiac conduction. More...

class	MMFMaxwell

class	MMFSWE

class	Monodomain
	A model for cardiac conduction. More...

class	MovingFrameFar

class	MovingFrameWall

class	NavierStokesAdvection

class	NavierStokesCFE

class	NavierStokesCFEAxisym

class	NavierStokesImplicitCFE

class	NekMatrix

class	NekMatrix< DataType, StandardMatrixTag >
	Standard Matrix. More...

class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, BlockMatrixTag >

class	NekMatrix< NekMatrix< DataType, InnerMatrixType >, ScaledMatrixTag >

class	NekPoint

class	NekPreconCfsOperators

class	NekSparseDiagBlkMatrix

class	NekSparseMatrix

class	NekVector

class	NoAdvection

class	NonlinearPeregrine

class	NonlinearSWE

class	NonlinearSWESolver

class	NonSmoothShockCapture
	Non Smooth artificial diffusion for shock capture for compressible flow problems. More...

class	NoSolver

struct	OneD

struct	PairHash

class	PanditGilesDemir03

class	ParseUtils

class	PengRobinsonEoS
	Peng-Robinson equation of state: p = RT/(1/rho - b) - aAlpha(T/Tc) / (1/rho^2 + 2b/rho - b^2) with a = 0.45724 * (RTc)^2 / Pc b = 0.0778 (RTc) / Pc Alpha(T/Tc) = [1 + fw (1 - sqrt(T/ Tc))]^2 fw = 0.37464 + 1.54226omega - 0.2699omega*omega. More...

class	Poisson

class	PowerPressureArea

class	PreconCfs

class	PreconCfsBRJ

class	PressureInflowFileBC
	Pressure inflow boundary conditions for compressible flow problems where either the density and the velocities are assigned from a file or the full state is assigned from a file (depending on the problem type, either subsonic or supersonic). More...

class	PressureMachTemperatureBC
	Boundary condition in terms of pressure, Mach number and temperature. P should be defined in the "rho" entry, T in the "E" entry and the Mach number in each direction in the corresponding momentum variable. This state is converted to conserved variables and a Dirichlet condition is applied. More...

class	PressureOutflowBC
	Pressure outflow boundary conditions for compressible flow problems. More...

class	PressureOutflowNonReflectiveBC
	Pressure outflow non-reflective boundary conditions for compressible flow problems. More...

class	Projection

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...

struct	PushBackFunctor
	Helper functors for holding a vector of numbers to be parsed by boost::spirit. More...

class	QInflow

struct	RawType

struct	RawType< const std::shared_ptr< T > >

struct	RawType< const volatile std::shared_ptr< T > >

struct	RawType< std::shared_ptr< T > >

struct	RawType< volatile std::shared_ptr< T > >

class	RCROutflow

class	RedlichKwongEoS
	Redlich-Kwong equation of state: p = RT/(1/rho - b) - a/( sqrt(T / Tc) * (1/rho^2 + b/rho) with a = 0.42748 * (RTc)^2 / Pc b = 0.08664 (R*Tc) / Pc. More...

class	RiemannInvariantBC
	Outflow characteristic boundary conditions for compressible flow problems. More...

class	RinglebFlowBC
	Wall boundary conditions for compressible flow problems. More...

class	RoeSolver

class	RoeSolverSIMD

class	ROutflow

class	ShallowWaterSystem
	Base class for unsteady solvers. More...

class	SkewSymmetricAdvection

class	SmoothedProfileMethod

class	StagnationInflowBC
	Stagnation conditions inflow boundary conditions for compressible flow problems where the energy and density are prescribed. More...

class	StandardExtrapolate

class	StaticWall

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

class	SubSteppingExtrapolateWeakPressure

struct	SymmetricBandedMatrixFuncs

struct	SymmetricMatrixFuncs

class	SymmetryBC
	Symmetry boundary conditions for compressible flow problems. More...

class	TemplatePressureArea

class	TenTusscher06

class	TerminalOutflow
	A global linear system. More...

class	TestData
	The TestData class is responsible for parsing a test XML file and storing the data. More...

struct	TesterException
	Subclass of std::runtime_error to handle exceptions raised by Tester. More...

struct	ThreeD

class	TimeDependentBC
	Time dependent boundary condition. More...

class	TimeDependentInflow

class	TransMovingWall

struct	TriangularBandedMatrixFuncs

struct	TriangularMatrixFuncs

struct	TwoD

class	UInflow
	A global linear system. More...

class	UndefinedInOutflow

class	UnsteadyAdvection

class	UnsteadyAdvectionDiffusion

class	UnsteadyDiffusion

class	UnsteadyInviscidBurgers

class	UnsteadyReactionDiffusion

class	UnsteadyViscousBurgers

struct	UpperTriangularBandedMatrixFuncs

struct	UpperTriangularMatrixFuncs

class	UpwindPulseSolver

class	VanDerWaalsEoS
	van der Waals equation of state: p = RT/(1/rho - b) - a * rho^2 with a = 27/64 * (RTc)^2 / Pc b = 1/8 (R*Tc) / Pc More...

class	VariableConverter

class	VCSImplicit

class	VCSMapping

class	VCSWeakPressure

class	VelocityCorrectionScheme

class	VortexWaveInteraction

class	WallBC
	Wall boundary conditions for compressible flow problems. More...

class	WallRotationalBC
	Wall boundary conditions for Rotational compressible flow problems. More...

class	WallViscousBC
	Wall boundary conditions for viscous compressible flow problems. More...

class	WeakPressureExtrapolate

class	Winslow99

struct	WomersleyParams

Typedefs
typedef double	NekDouble

typedef float	NekSingle

typedef std::int32_t	NekInt

typedef std::int32_t	NekInt32

typedef std::int64_t	NekInt64

typedef std::uint32_t	NekUInt

typedef std::uint32_t	NekUInt32

typedef std::uint64_t	NekUInt64

template<typename T >
using	RawType_t = typename RawType< T >::type

template<class T >
using	TensorOfArray2D = Array< OneD, Array< OneD, T > >

template<class T >
using	TensorOfArray3D = Array< OneD, Array< OneD, Array< OneD, T > > >

template<class T >
using	TensorOfArray4D = Array< OneD, Array< OneD, Array< OneD, Array< OneD, T > > > >

template<class T >
using	TensorOfArray5D = Array< OneD, Array< OneD, Array< OneD, Array< OneD, Array< OneD, T > > > > >

typedef std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > >	SharedNekMatrixPtr

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

typedef std::shared_ptr< DNekScalMat >	DNekScalMatSharedPtr

typedef std::shared_ptr< NekMatrix< NekSingle, StandardMatrixTag > >	SharedSNekMatrixPtr

typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >	SNekScalMat

typedef std::shared_ptr< SNekScalMat >	SNekScalMatSharedPtr

typedef NekVector< NekDouble >	DNekVec

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 std::shared_ptr< DNekMat >	DNekMatSharedPtr

typedef std::shared_ptr< DNekBlkMat >	DNekBlkMatSharedPtr

typedef std::shared_ptr< BlkMatDNekBlkMat >	BlkMatDNekBlkMatSharedPtr

typedef std::shared_ptr< DNekScalBlkMat >	DNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatDNekScalBlkMat >	BlkMatDNekScalBlkMatSharedPtr

typedef LinearSystem	DNekLinSys

typedef std::shared_ptr< DNekLinSys >	DNekLinSysSharedPtr

typedef LinearSystem	DNekScalLinSys

typedef std::shared_ptr< DNekScalLinSys >	DNekScalLinSysSharedPtr

typedef NekVector< NekSingle >	SNekVec

typedef NekMatrix< NekSingle, StandardMatrixTag >	SNekMat

typedef NekMatrix< NekSingle, StandardMatrixTag >	SDenseMatrix

typedef NekMatrix< SDenseMatrix, ScaledMatrixTag >	SScaledMatrix

typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, BlockMatrixTag >	SNekBlkMat

typedef NekMatrix< SDenseMatrix, BlockMatrixTag >	SBlockMatrix

typedef NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatSNekBlkMat

typedef NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >	SNekScalBlkMat

typedef NekMatrix< NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag >, BlockMatrixTag >	BlkMatSNekScalBlkMat

typedef std::shared_ptr< SNekMat >	SNekMatSharedPtr

typedef std::shared_ptr< SNekBlkMat >	SNekBlkMatSharedPtr

typedef std::shared_ptr< BlkMatSNekBlkMat >	BlkMatSNekBlkMatSharedPtr

typedef std::shared_ptr< SNekScalBlkMat >	SNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatSNekScalBlkMat >	BlkMatSNekScalBlkMatSharedPtr

typedef unsigned int	IndexType

typedef Array< OneD, IndexType >	IndexVector

typedef std::pair< IndexType, IndexType >	CoordType

typedef NekDouble	COOEntryType

typedef std::map< CoordType, NekDouble >	COOMatType

typedef COOMatType::const_iterator	COOMatTypeConstIt

typedef std::shared_ptr< COOMatType >	COOMatTypeSharedPtr

typedef Array< OneD, COOMatType >	COOMatVector

typedef Array< OneD, NekDouble >	BCOEntryType

typedef std::map< CoordType, BCOEntryType >	BCOMatType

typedef BCOMatType::const_iterator	BCOMatTypeConstIt

typedef std::shared_ptr< BCOMatType >	BCOMatTypeSharedPtr

typedef Array< OneD, BCOMatType >	BCOMatVector

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

typedef std::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 std::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 std::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 std::shared_ptr< ArtificialDiffusion >	ArtificialDiffusionSharedPtr
	A shared pointer to a artificial diffusion object. More...

typedef LibUtilities::NekFactory< std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const int >	ArtificialDiffusionFactory
	Declaration of the artificial diffusion factory. More...

typedef std::shared_ptr< CFSBndCond >	CFSBndCondSharedPtr
	A shared pointer to a boundary condition object. More...

typedef LibUtilities::NekFactory< std::string, CFSBndCond, const LibUtilities::SessionReaderSharedPtr &, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const Array< OneD, Array< OneD, NekDouble > > &, const Array< OneD, Array< OneD, NekDouble > > &, const int, const int, const int >	CFSBndCondFactory
	Declaration of the boundary condition factory. More...

typedef std::shared_ptr< DiffusionLDGNS >	DiffusionLDGNSSharedPtr

typedef std::shared_ptr< EquationOfState >	EquationOfStateSharedPtr
	A shared pointer to an equation of state object. More...

typedef LibUtilities::NekFactory< std::string, EquationOfState, const LibUtilities::SessionReaderSharedPtr & >	EquationOfStateFactory
	Declaration of the equation of state factory. More...

using	vec_t = tinysimd::simd< NekDouble >

typedef std::shared_ptr< VariableConverter >	VariableConverterSharedPtr

typedef LibUtilities::NekFactory< std::string, PreconCfs, const Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr & >	PreconCfsFactory
	Declaration of the boundary condition factory. More...

typedef std::shared_ptr< PreconCfs >	PreconCfsSharedPtr

typedef std::shared_ptr< IncBaseCondition >	IncBaseConditionSharedPtr

typedef LibUtilities::NekFactory< std::string, IncBaseCondition, const LibUtilities::SessionReaderSharedPtr, Array< OneD, MultiRegions::ExpListSharedPtr >, Array< OneD, SpatialDomains::BoundaryConditionShPtr >, Array< OneD, MultiRegions::ExpListSharedPtr >, int, int, int >	IncBCFactory

typedef std::shared_ptr< IncBoundaryConditions >	IncBoundaryConditionsSharedPtr

typedef struct Nektar::coupledSolverMatrices	CoupledSolverMatrices

typedef std::shared_ptr< CoupledLocalToGlobalC0ContMap >	CoupledLocalToGlobalC0ContMapSharedPtr

typedef std::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 std::shared_ptr< HighOrderOutflow >	HighOrderOutflowSharedPtr

typedef std::shared_ptr< ImplicitExtrapolate >	ImplicitExtrapolateSharedPtr

typedef std::complex< double >	NekComplexDouble

typedef std::shared_ptr< WomersleyParams >	WomersleyParamsSharedPtr

typedef std::shared_ptr< IncNavierStokes >	IncNavierStokesSharedPtr

typedef std::shared_ptr< MappingExtrapolate >	MappingExtrapolateSharedPtr

typedef std::shared_ptr< SmoothedProfileMethod >	SmoothedProfileMethodSharedPtr

typedef std::shared_ptr< StandardExtrapolate >	StandardExtrapolateSharedPtr

typedef std::shared_ptr< SubSteppingExtrapolate >	SubSteppingExtrapolateSharedPtr

typedef std::shared_ptr< SubSteppingExtrapolateWeakPressure >	SubSteppingExtrapolateWeakPressureSharedPtr

typedef std::shared_ptr< VCSMapping >	VCSMappingSharedPtr

typedef std::shared_ptr< VelocityCorrectionScheme >	VelocityCorrectionSchemeSharedPtr

typedef std::shared_ptr< VCSImplicit >	VCSImplicitSharedPtr

typedef std::shared_ptr< VCSWeakPressure >	VCSWeakPressureSharedPtr

typedef std::shared_ptr< WeakPressureExtrapolate >	WeakPressureExtrapolateSharedPtr

typedef std::shared_ptr< FilterAeroForcesSPM >	FilterAeroForcesSPMSharedPtr

typedef std::shared_ptr< FilterMovingBody >	FilterMovingBodySharedPtr

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

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

typedef std::shared_ptr< CoupledAssemblyMap >	CoupledAssemblyMapSharedPtr

typedef std::shared_ptr< AInflow >	AInflowSharedPtr

typedef std::shared_ptr< BetaPressureArea >	BetaPressureAreaSharedPtr

typedef std::shared_ptr< EmpiricalPressureArea >	EmpiricalPressureAreaSharedPtr

typedef std::shared_ptr< PowerPressureArea >	PowerPressureAreaSharedPtr

typedef std::shared_ptr< PulseWaveBoundary >	PulseWaveBoundarySharedPtr

typedef LibUtilities::NekFactory< std::string, PulseWaveBoundary, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr & >	BoundaryFactory

typedef std::shared_ptr< PulseWavePressureArea >	PulseWavePressureAreaSharedPtr

typedef LibUtilities::NekFactory< std::string, PulseWavePressureArea, Array< OneD, MultiRegions::ExpListSharedPtr > &, const LibUtilities::SessionReaderSharedPtr & >	PressureAreaFactory

typedef std::shared_ptr< InterfacePoint >	InterfacePointShPtr

typedef std::shared_ptr< PulseWaveSystem >	PulseWaveSystemSharedPtr

typedef std::shared_ptr< QInflow >	QInflowSharedPtr

typedef std::shared_ptr< RCROutflow >	RCROutflowSharedPtr

typedef std::shared_ptr< ROutflow >	ROutflowSharedPtr

typedef std::shared_ptr< TemplatePressureArea >	TemplatePressureAreaSharedPtr

typedef std::shared_ptr< TerminalOutflow >	TerminalOutflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...

typedef std::shared_ptr< TimeDependentInflow >	TimeDependentInflowSharedPtr

typedef std::shared_ptr< UInflow >	UInflowSharedPtr
	Pointer to a PulseWaveOutflow object. More...

typedef std::shared_ptr< UndefinedInOutflow >	UndefinedInOutflowSharedPtr

typedef std::shared_ptr< Metric >	MetricSharedPtr
	A shared pointer to an EquationSystem object. More...

Enumerations
enum	Direction { xDir = 0 , yDir = 1 , zDir = 2 }

enum	OutputFormat { eTecplot , eTecplotZones , eTecplotSingleBlock , eGmsh , eGnuplot }
	Enumeration a flags for output format. More...

enum	FlagType { eUseGlobal }
	Enumeration of flags for passing a list of options. More...

enum	ArrayWrapperType { eArrayCopy , eArrayWrapper }

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	TestType { eTestPlane , eTestCube , eTestLinearSphere , eTestNonlinearSphere , eFHNStandard , eFHNRogers , eFHNAlievPanf , SIZE_TestType , eTestPlane , eTestSteadyZonal , eTestUnsteadyZonal , eTestIsolatedMountain , eTestUnstableJet , eTestRossbyWave , SIZE_TestType }

enum	InitWaveType { eLeft , eBothEnds , eCenter , eLeftBottomCorner , ePoint , eSpiralDock , SIZE_InitWaveType }

enum	HBCType { eNOHBC , eHBCNeumann , eOBC , eConvectiveOBC }

enum	SolverType { eNoSolverType , eCoupledLinearisedNS , eSmoothedProfileMethod , eVCSMapping , eVelocityCorrectionScheme , eVCSWeakPressure , eWeakPressure , eVCSImplicit , eImplicit }

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	TestType { eTestPlane , eTestCube , eTestLinearSphere , eTestNonlinearSphere , eFHNStandard , eFHNRogers , eFHNAlievPanf , SIZE_TestType , eTestPlane , eTestSteadyZonal , eTestUnsteadyZonal , eTestIsolatedMountain , eTestUnstableJet , eTestRossbyWave , SIZE_TestType }

enum	ProblemType { eGeneral , eSolitaryWave , SIZE_ProblemType }

enum	VWIIterationType { eFixedAlpha , eFixedWaveForcing , eFixedAlphaWaveForcing , eFixedWaveForcingWithSubIterationOnAlpha , eVWIIterationTypeSize }

enum	CommandType { eNone , eSequential , eParallel }

Functions
template<typename Dim , typename DataType , typename ExtentListType >
std::shared_ptr< boost::multi_array_ref< DataType, Dim::Value > >	CreateStorage (const ExtentListType &extent)

template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 1 > >	CreateStorage (size_t d1)

template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 2 > >	CreateStorage (size_t d1, size_t d2)

template<typename DataType >
std::shared_ptr< boost::multi_array_ref< DataType, 3 > >	CreateStorage (size_t d1, size_t d2, size_t d3)

void	hash_combine (std::size_t &seed)

template<typename T , typename... Args>
void	hash_combine (std::size_t &seed, const T &v, Args... args)

template<typename T , typename... Args>
std::size_t	hash_combine (const T &v, Args... args)

template<typename Iter >
std::size_t	hash_range (Iter first, Iter last)

template<typename Iter >
void	hash_range (std::size_t &seed, Iter first, Iter last)

template<typename T >
bool	IsEqualImpl (const T &lhs, const T &rhs, std::false_type)

template<typename T >
bool	IsEqualImpl (const T &lhs, const T &rhs, std::true_type)

template<typename T >
bool	IsEqual (const T &lhs, const T &rhs)

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, typename Array< OneD, DataType >::size_type offset)

template<typename DataType >
Array< OneD, DataType >	operator+ (typename Array< OneD, DataType >::size_type 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, typename Array< OneD, DataType >::size_type n)

template<typename T1 , typename T2 >
bool	operator== (const Array< TwoD, T1 > &lhs, const Array< TwoD, T2 > &rhs)

template<typename T1 , typename T2 >
bool	operator!= (const Array< TwoD, T1 > &lhs, const Array< TwoD, T2 > &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 &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply

template<typename DataType , typename LhsDataType , typename LhsMatrixType >
SNekMat const NekSingle &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 &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >
const NekSingle &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,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
SNekMat const NekSingle 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,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply

template<typename LhsDataType >
const NekSingle void	MultiplyEqual (NekMatrix< LhsDataType, StandardMatrixTag > &lhs, typename boost::call_traits< LhsDataType >::const_reference rhs)

	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (MultiplyEqual,(1,(DNekMat &)),(1,(void)),(0,()),(1,(const NekDouble &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(MultiplyEqual

template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
SNekMat const NekSingle &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,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Multiply

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
SNekMat 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(AddEqual

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat 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(Add

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
SNekMat SNekMat 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,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Add

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename 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(Subtract

SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (SubtractNegatedLhs, 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 >
SNekMat SNekMat 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(SubtractEqual

SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (SubtractEqualNegatedLhs, 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 >
SNekMat SNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Subtract (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,(DNekMat)),(0,()),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(Subtract

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 DataType , typename LhsDataType , typename MatrixType >
NekVector< DataType >	operator* (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)

void	DiagonalBlockFullScalMatrixMultiply (NekVector< double > &result, const NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &lhs, const NekVector< double > &rhs)

void	DiagonalBlockFullScalMatrixMultiply (NekVector< NekSingle > &result, const NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &lhs, const NekVector< NekSingle > &rhs)

template<typename DataType , typename LhsDataType , typename LhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const DataType &rhs)

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >
void	Multiply (NekMatrix< ResultDataType, StandardMatrixTag > &result, const ResultDataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	Multiply (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	operator* (const DataType &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag >	operator* (const NekMatrix< RhsDataType, RhsMatrixType > &lhs, const 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< LhsDataType, StandardMatrixTag > &result, const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType > >::value &&CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType > >::value >::type *p=nullptr)

template<typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< RhsInnerType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename std::enable_if< std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, RhsInnerType >::value &&CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > >::value >::type *t=0)

template<typename DataType , typename RhsInnerType , typename RhsMatrixType >
void	MultiplyEqual (NekMatrix< DataType, StandardMatrixTag > &result, const NekMatrix< RhsInnerType, RhsMatrixType > &rhs, typename std::enable_if< !std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, DataType >::value\|\|!CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > >::value >::type *t=0)

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag >	Multiply (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >
NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag >	operator* (const NekMatrix< LhsDataType, LhsMatrixType > &lhs, const NekMatrix< RhsDataType, RhsMatrixType > &rhs)

template<typename DataType , typename RhsDataType , typename RhsMatrixType >
void	AddEqual (NekMatrix< DataType, StandardMatrixTag > &result, 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 LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	operator+ (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 LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >
NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag >	operator- (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 DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyBandedMatrix (DataType result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > >::value >::type *p=nullptr)

template<typename DataType , typename LhsDataType >
void	NekMultiplyBandedMatrix (DataType result, const NekMatrix< LhsDataType, BlockMatrixTag > &lhs, const DataType rhs, typename std::enable_if< !CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > >::value >::type *p=nullptr)

template<typename DataType , typename LhsInnerMatrixType >
void	FullBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)

template<typename DataType , typename LhsInnerMatrixType >
void	DiagonalBlockMatrixMultiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)

template<typename DataType >
void	NekMultiplyLowerTriangularMatrix (DataType result, const NekMatrix< DataType, StandardMatrixTag > &lhs, const DataType rhs)

template<typename DataType >
void	NekMultiplyLowerTriangularMatrix (DataType result, const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &lhs, const DataType rhs)

template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyLowerTriangularMatrix (DataType result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType rhs)

template<typename DataType >
void	NekMultiplyUpperTriangularMatrix (DataType result, const NekMatrix< DataType, StandardMatrixTag > &lhs, const DataType rhs)

template<typename DataType >
void	NekMultiplyUpperTriangularMatrix (DataType result, const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &lhs, const DataType rhs)

template<typename DataType , typename LhsDataType , typename MatrixType >
void	NekMultiplyUpperTriangularMatrix (DataType result, const NekMatrix< LhsDataType, MatrixType > &lhs, const DataType rhs)

template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (DataType result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=nullptr)

template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplySymmetricMatrix (DataType result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType rhs, typename std::enable_if< !CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=nullptr)

template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (DataType result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType rhs, typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=nullptr)

template<typename DataType , typename InnerMatrixType , typename MatrixTag >
void	NekMultiplyFullMatrix (DataType result, const NekMatrix< InnerMatrixType, MatrixTag > &lhs, const DataType rhs, typename std::enable_if< !CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *p=nullptr)

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

template<typename DataType , typename LhsInnerMatrixType >
NekVector< NekSingle > const NekVector< NekSingle > &void	Multiply (NekVector< DataType > &result, const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &lhs, const NekVector< DataType > &rhs)

	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

template<typename DataType , typename LhsDataType , typename MatrixType >
NekVector< NekSingle > const NekVector< NekSingle > &NekVector< DataType >	Multiply (const NekMatrix< LhsDataType, MatrixType > &lhs, const NekVector< DataType > &rhs)

	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (Multiply, NEKTAR_ALL_MATRIX_TYPES,(1,(NekVector< NekDouble >)),(0,()),(1,(const NekVector< NekDouble > &))) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(Multiply

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)

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 void	Add (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template void	AddNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &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 void	AddEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)

template void	AddEqualNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)

template<typename LhsDataType , typename RhsDataType >
NekVector< LhsDataType >	Add (const NekVector< LhsDataType > &lhs, const NekVector< RhsDataType > &rhs)

template NekVector< NekDouble >	Add (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)

template NekVector< NekSingle >	Add (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &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 void	Subtract (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template void	SubtractNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &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 void	SubtractEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)

template void	SubtractEqualNegatedLhs (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)

template<typename DataType >
NekVector< DataType >	Subtract (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)

template NekVector< NekDouble >	Subtract (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)

template NekVector< NekSingle >	Subtract (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template<typename ResultDataType , typename InputDataType >
void	Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)

template<typename ResultDataType , typename InputDataType >
void	Divide (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekSingle &rhs)

template void	Divide (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)

template void	Divide (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekSingle &rhs)

template<typename ResultDataType >
void	DivideEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)

template<typename ResultDataType >
void	DivideEqual (NekVector< ResultDataType > &result, const NekSingle &rhs)

template void	DivideEqual (NekVector< NekDouble > &result, const NekDouble &rhs)

template void	DivideEqual (NekVector< NekSingle > &result, const NekSingle &rhs)

template<typename DataType >
NekVector< DataType >	Divide (const NekVector< DataType > &lhs, const NekDouble &rhs)

template<typename DataType >
NekVector< DataType >	Divide (const NekVector< DataType > &lhs, const NekSingle &rhs)

template NekVector< NekDouble >	Divide (const NekVector< NekDouble > &lhs, const NekDouble &rhs)

template NekVector< NekSingle >	Divide (const NekVector< NekSingle > &lhs, const NekSingle &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 void	Multiply (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &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 void	MultiplyEqual (NekVector< NekSingle > &result, const NekVector< NekSingle > &rhs)

template<typename DataType , typename InputDataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekVector< InputDataType > &rhs)

template NekVector< NekDouble >	Multiply (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)

template NekVector< NekSingle >	Multiply (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekDouble &rhs)

template<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekVector< InputDataType > &lhs, const NekSingle &rhs)

template void	Multiply (NekVector< NekDouble > &result, const NekVector< NekDouble > &lhs, const NekDouble &rhs)

template void	Multiply (NekVector< NekSingle > &result, const NekVector< NekSingle > &lhs, const NekSingle &rhs)

template<typename ResultDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekDouble &rhs)

template<typename ResultDataType >
void	MultiplyEqual (NekVector< ResultDataType > &result, const NekSingle &rhs)

template void	MultiplyEqual (NekVector< NekDouble > &result, const NekDouble &rhs)

template void	MultiplyEqual (NekVector< NekSingle > &result, const NekSingle &rhs)

template<typename DataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekDouble &rhs)

template<typename DataType >
NekVector< DataType >	Multiply (const NekVector< DataType > &lhs, const NekSingle &rhs)

template NekVector< NekDouble >	Multiply (const NekVector< NekDouble > &lhs, const NekDouble &rhs)

template NekVector< NekSingle >	Multiply (const NekVector< NekSingle > &lhs, const NekSingle &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<typename ResultDataType , typename InputDataType >
void	Multiply (NekVector< ResultDataType > &result, const NekSingle &lhs, const NekVector< InputDataType > &rhs)

template<typename ResultDataType , typename InputDataType >
void	MultiplyInvertedLhs (NekVector< ResultDataType > &result, const NekSingle &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 void	MultiplyInvertedLhs (NekVector< NekSingle > &result, const NekSingle &lhs, const NekVector< NekSingle > &rhs)

template void	Multiply (NekVector< NekSingle > &result, const NekSingle &lhs, const NekVector< NekSingle > &rhs)

template<typename DataType >
NekVector< DataType >	Multiply (const DataType &lhs, const NekVector< DataType > &rhs)

template NekVector< NekDouble >	Multiply (const NekDouble &lhs, const NekVector< NekDouble > &rhs)

template NekVector< NekSingle >	Multiply (const NekSingle &lhs, const NekVector< NekSingle > &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 std::ostream &	operator<< (std::ostream &os, const NekVector< NekSingle > &rhs)

template<typename DataType >
NekVector< DataType >	createVectorFromPoints (const NekPoint< DataType > &source, const NekPoint< DataType > &dest)

template NekVector< NekDouble >	createVectorFromPoints (const NekPoint< NekDouble > &source, const NekPoint< NekDouble > &dest)

template NekVector< NekSingle >	createVectorFromPoints (const NekPoint< NekSingle > &source, const NekPoint< NekSingle > &dest)

template<typename DataType >
NekPoint< DataType >	findPointAlongVector (const NekVector< DataType > &lhs, const DataType &t)

template NekPoint< NekDouble >	findPointAlongVector (const NekVector< NekDouble > &lhs, const NekDouble &t)

template NekPoint< NekSingle >	findPointAlongVector (const NekVector< NekSingle > &lhs, const NekSingle &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 bool	operator== (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &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 bool	operator!= (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template<typename DataType >
std::vector< DataType >	FromString (const std::string &str)

template std::vector< NekDouble >	FromString (const std::string &str)

template<typename DataType >
DataType	L1Norm (const NekVector< DataType > &v)

template NekDouble	L1Norm (const NekVector< NekDouble > &v)

template NekSingle	L1Norm (const NekVector< NekSingle > &v)

template<typename DataType >
DataType	L2Norm (const NekVector< DataType > &v)

template NekDouble	L2Norm (const NekVector< NekDouble > &v)

template NekSingle	L2Norm (const NekVector< NekSingle > &v)

template<typename DataType >
DataType	InfinityNorm (const NekVector< DataType > &v)

template NekDouble	InfinityNorm (const NekVector< NekDouble > &v)

template NekSingle	InfinityNorm (const NekVector< NekSingle > &v)

template<typename DataType >
NekVector< DataType >	Negate (const NekVector< DataType > &v)

template NekVector< NekDouble >	Negate (const NekVector< NekDouble > &v)

template NekVector< NekSingle >	Negate (const NekVector< NekSingle > &v)

template<typename DataType >
void	NegateInPlace (NekVector< DataType > &v)

template void	NegateInPlace (NekVector< NekDouble > &v)

template void	NegateInPlace (NekVector< NekSingle > &v)

template<typename DataType >
DataType	Magnitude (const NekVector< DataType > &v)

template NekDouble	Magnitude (const NekVector< NekDouble > &v)

template NekSingle	Magnitude (const NekVector< NekSingle > &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 NekSingle	Dot (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template<typename DataType >
void	Normalize (NekVector< DataType > &v)

template void	Normalize (NekVector< NekDouble > &v)

void	NegateInPlace (NekDouble &v)

void	InvertInPlace (NekDouble &v)

template void	Normalize (NekVector< NekSingle > &v)

void	NegateInPlace (NekSingle &v)

void	InvertInPlace (NekSingle &v)

template<typename DataType >
NekVector< DataType >	Cross (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)

template NekVector< NekDouble >	Cross (const NekVector< NekDouble > &lhs, const NekVector< NekDouble > &rhs)

template NekVector< NekSingle >	Cross (const NekVector< NekSingle > &lhs, const NekVector< NekSingle > &rhs)

template<typename DataType >
std::string	AsString (const NekVector< DataType > &v)

template std::string	AsString (const NekVector< NekDouble > &v)

template std::string	AsString (const NekVector< NekSingle > &v)

template<typename DataType >
NekVector< DataType >	operator* (const NekVector< DataType > &lhs, const NekDouble &rhs)

template<typename DataType >
NekVector< DataType >	operator* (const NekDouble &lhs, const NekVector< DataType > &rhs)

template<typename DataType >
NekVector< DataType >	operator* (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)

template<typename DataType >
NekVector< DataType >	operator/ (const NekVector< DataType > &lhs, const NekDouble &rhs)

template<typename DataType >
NekVector< DataType >	operator+ (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)

template<typename DataType >
NekVector< DataType >	operator- (const NekVector< DataType > &lhs, const NekVector< DataType > &rhs)

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)

template NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >	Transpose (NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &rhs)

template void	NegateInPlace (NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > &v)

void	convertCooToBco (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 NekMatrix< NekSingle, StandardMatrixTag >	Transpose (NekMatrix< NekSingle, StandardMatrixTag > &rhs)

template<typename DataType >
void	NegateInPlace (NekMatrix< DataType, StandardMatrixTag > &m)

template void	NegateInPlace (NekMatrix< double, StandardMatrixTag > &v)

template void	NegateInPlace (NekMatrix< NekSingle, 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)

MemPool &	GetMemoryPool ()

template<typename T >
std::ostream &	operator<< (std::ostream &os, const CountedObject< T > &lhs)

	BOOST_AUTO_TEST_CASE (TestCanGetRawPtr)

template<typename LhsScaledInnerMatrixType , typename LhsBlockInnerMatrixType , typename RhsScaledInnerMatrixType , typename RhsBlockInnerMatrixType >
void	RunAllAddCombinations (const NekMatrix< NekDouble, StandardMatrixTag > &l1, const NekMatrix< NekMatrix< NekDouble, LhsScaledInnerMatrixType >, ScaledMatrixTag > &l2, const NekMatrix< NekMatrix< NekDouble, LhsBlockInnerMatrixType >, BlockMatrixTag > &l3, const NekMatrix< NekDouble, StandardMatrixTag > &r1, const NekMatrix< NekMatrix< NekDouble, RhsScaledInnerMatrixType >, ScaledMatrixTag > &r2, const NekMatrix< NekMatrix< NekDouble, RhsBlockInnerMatrixType >, BlockMatrixTag > &r3, const NekMatrix< NekDouble, StandardMatrixTag > &result)

template<typename LhsScaledInnerMatrixType , typename LhsBlockInnerMatrixType , typename RhsScaledInnerMatrixType , typename RhsBlockInnerMatrixType >
void	RunAllSubCombinations (const NekMatrix< NekDouble, StandardMatrixTag > &l1, const NekMatrix< NekMatrix< NekDouble, LhsScaledInnerMatrixType >, ScaledMatrixTag > &l2, const NekMatrix< NekMatrix< NekDouble, LhsBlockInnerMatrixType >, BlockMatrixTag > &l3, const NekMatrix< NekDouble, StandardMatrixTag > &r1, const NekMatrix< NekMatrix< NekDouble, RhsScaledInnerMatrixType >, ScaledMatrixTag > &r2, const NekMatrix< NekMatrix< NekDouble, RhsBlockInnerMatrixType >, BlockMatrixTag > &r3, const NekMatrix< NekDouble, StandardMatrixTag > &result)

template<typename NumberType >
void	GenerateMatrices (const NekMatrix< NumberType, StandardMatrixTag > &m1, NumberType scale, unsigned int blockRows, unsigned int blockColumns, std::shared_ptr< NekMatrix< NekMatrix< NumberType, StandardMatrixTag >, ScaledMatrixTag > > &m2, std::shared_ptr< NekMatrix< NekMatrix< NumberType >, BlockMatrixTag > > &m3)

	BOOST_AUTO_TEST_CASE (TestABPlusbCScaled)

	BOOST_AUTO_TEST_CASE (TestABPlusbCBlock)

void	GenerateFullMatrices (double values[], double scale, std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > &m1, std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, ScaledMatrixTag > > &m2, std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, BlockMatrixTag > > &m3)

void	GenerateUpperTriangularMatrices (NekDouble values[], NekDouble scale, std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > &m1, std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, ScaledMatrixTag > > &m2, std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, BlockMatrixTag > > &m3)

CellModelFactory &	GetCellModelFactory ()

ProtocolFactory &	GetProtocolFactory ()

StimulusFactory &	GetStimulusFactory ()

ArtificialDiffusionFactory &	GetArtificialDiffusionFactory ()
	Declaration of the artificial diffusion factory singleton. More...

CFSBndCondFactory &	GetCFSBndCondFactory ()
	Declaration of the boundary condition factory singleton. More...

EquationOfStateFactory &	GetEquationOfStateFactory ()
	Declaration of the equation of state factory singleton. More...

PreconCfsFactory &	GetPreconCfsFactory ()
	Declaration of the boundary condition factory singleton. More...

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...

template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value \|\| tinysimd::is_vector_floating_point<T>::value>::type>
void	RoeKernel (T &rhoL, T &rhouL, T &rhovL, T &rhowL, T &EL, T &rhoR, T &rhouR, T &rhovR, T &rhowR, T &ER, T &rhof, T &rhouf, T &rhovf, T &rhowf, T &Ef, NekDouble gamma)

IncBCFactory &	GetIncBCFactory ()

ExtrapolateFactory &	GetExtrapolateFactory ()

DNekMat	MappingIdealToRef (SpatialDomains::GeometrySharedPtr geom)

BoundaryFactory &	GetBoundaryFactory ()

PressureAreaFactory &	GetPressureAreaFactory ()

MetricFactory &	GetMetricFactory ()

bool	EmptyString (const char *s)
	Check to see whether the given string `s` is empty (or null). More...

Variables
const char *const	FlagTypeMap [] = {"UseGlobal"}
	String map for FlagType enumeration. More...

static Array< OneD, int >	NullInt1DArray

static Array< OneD, NekDouble >	NullNekDouble1DArray

static Array< OneD, Array< OneD, NekDouble > >	NullNekDoubleArrayOfArray

static Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	NullNekDoubleTensorOfArray3D

	NEKTAR_ALL_MATRIX_TYPES_SINGLE

	void

SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX (AddEqualNegatedLhs, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(AddEqualNegatedLhs

SNekMat	NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES (AddNegatedLhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(AddNegatedLhs

	NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE

	NEKTAR_BLOCK_MATRIX_TYPES_SINGLE

	NekVector< NekSingle >

static DNekMatSharedPtr	NullDNekMatSharedPtr

static DNekScalMatSharedPtr	NullDNekScalMatSharedPtr

static DNekScalBlkMatSharedPtr	NullDNekScalBlkMatSharedPtr

static Array< OneD, DNekBlkMatSharedPtr >	NullArrayDNekBlkMatSharedPtr

static SNekMatSharedPtr	NullSNekMatSharedPtr

static SNekScalMatSharedPtr	NullSNekScalMatSharedPtr

static SNekScalBlkMatSharedPtr	NullSNekScalBlkMatSharedPtr

static Array< OneD, SNekBlkMatSharedPtr >	NullArraySNekBlkMatSharedPtr

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	TestTypeMap []

const char *const	InitWaveTypeMap []

const std::string	kEquationTypeStr []

const std::string	kAdvectionFormStr []

static PulseWaveBoundarySharedPtr	NullPulseWaveBoundarySharedPtr

static PulseWavePressureAreaSharedPtr	NullPulseWavePressureAreaSharedPtr

const char *const	UpwindTypeMapPulse []

const char *const	ProblemTypeMap [] = {"General", "SolitaryWave"}

const std::string	VWIIterationTypeMap []

Typedef Documentation

◆ AInflowSharedPtr

typedef std::shared_ptr<AInflow> Nektar::AInflowSharedPtr

Definition at line 48 of file AInflow.h.

◆ ArtificialDiffusionFactory

typedef LibUtilities::NekFactory< std::string, ArtificialDiffusion, const LibUtilities::SessionReaderSharedPtr &, const Array<OneD, MultiRegions::ExpListSharedPtr> &, const int> Nektar::ArtificialDiffusionFactory

Declaration of the artificial diffusion factory.

Definition at line 60 of file ArtificialDiffusion.h.

◆ ArtificialDiffusionSharedPtr

typedef std::shared_ptr<ArtificialDiffusion> Nektar::ArtificialDiffusionSharedPtr

A shared pointer to a artificial diffusion object.

Definition at line 53 of file ArtificialDiffusion.h.

◆ BCOEntryType

typedef Array<OneD, NekDouble> Nektar::BCOEntryType

Definition at line 62 of file SparseMatrixFwd.hpp.

◆ BCOMatType

typedef std::map<CoordType, BCOEntryType> Nektar::BCOMatType

Definition at line 63 of file SparseMatrixFwd.hpp.

◆ BCOMatTypeConstIt

typedef BCOMatType::const_iterator Nektar::BCOMatTypeConstIt

Definition at line 64 of file SparseMatrixFwd.hpp.

◆ BCOMatTypeSharedPtr

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

Definition at line 65 of file SparseMatrixFwd.hpp.

◆ BCOMatVector

typedef Array<OneD, BCOMatType> Nektar::BCOMatVector

Definition at line 66 of file SparseMatrixFwd.hpp.

◆ BetaPressureAreaSharedPtr

typedef std::shared_ptr<BetaPressureArea> Nektar::BetaPressureAreaSharedPtr

Definition at line 47 of file BetaPressureArea.h.

◆ BlkMatDNekBlkMat

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

Definition at line 64 of file NekTypeDefs.hpp.

◆ BlkMatDNekBlkMatSharedPtr

typedef std::shared_ptr<BlkMatDNekBlkMat> Nektar::BlkMatDNekBlkMatSharedPtr

Definition at line 78 of file NekTypeDefs.hpp.

◆ BlkMatDNekScalBlkMat

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

Definition at line 73 of file NekTypeDefs.hpp.

◆ BlkMatDNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatDNekScalBlkMat > Nektar::BlkMatDNekScalBlkMatSharedPtr

Definition at line 80 of file NekTypeDefs.hpp.

◆ BlkMatSNekBlkMat

typedef NekMatrix< NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatSNekBlkMat

Definition at line 111 of file NekTypeDefs.hpp.

◆ BlkMatSNekBlkMatSharedPtr

typedef std::shared_ptr<BlkMatSNekBlkMat> Nektar::BlkMatSNekBlkMatSharedPtr

Definition at line 125 of file NekTypeDefs.hpp.

◆ BlkMatSNekScalBlkMat

typedef NekMatrix<NekMatrix<NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag>, BlockMatrixTag> Nektar::BlkMatSNekScalBlkMat

Definition at line 120 of file NekTypeDefs.hpp.

◆ BlkMatSNekScalBlkMatSharedPtr

typedef std::shared_ptr< BlkMatSNekScalBlkMat > Nektar::BlkMatSNekScalBlkMatSharedPtr

Definition at line 127 of file NekTypeDefs.hpp.

◆ BlockMatrix

typedef NekMatrix<DenseMatrix, BlockMatrixTag> Nektar::BlockMatrix

Definition at line 59 of file NekTypeDefs.hpp.

◆ BoundaryFactory

typedef LibUtilities::NekFactory<std::string, PulseWaveBoundary, Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &, PulseWavePressureAreaSharedPtr &> Nektar::BoundaryFactory

Definition at line 58 of file PulseWaveBoundary.h.

◆ CellModelFactory

typedef LibUtilities::NekFactory<std::string, CellModel, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr &> Nektar::CellModelFactory

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

Definition at line 61 of file CellModel.h.

◆ CellModelSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 55 of file CellModel.h.

◆ CFSBndCondFactory

typedef LibUtilities::NekFactory< std::string, CFSBndCond, const LibUtilities::SessionReaderSharedPtr &, const Array<OneD, MultiRegions::ExpListSharedPtr> &, const Array<OneD, Array<OneD, NekDouble> > &, const Array<OneD, Array<OneD, NekDouble> > &, const int, const int, const int> Nektar::CFSBndCondFactory

Declaration of the boundary condition factory.

Definition at line 60 of file CFSBndCond.h.

◆ CFSBndCondSharedPtr

typedef std::shared_ptr<CFSBndCond> Nektar::CFSBndCondSharedPtr

A shared pointer to a boundary condition object.

Definition at line 51 of file CFSBndCond.h.

◆ COOEntryType

typedef NekDouble Nektar::COOEntryType

Definition at line 55 of file SparseMatrixFwd.hpp.

◆ COOMatType

typedef std::map<CoordType, NekDouble> Nektar::COOMatType

Definition at line 56 of file SparseMatrixFwd.hpp.

◆ COOMatTypeConstIt

typedef COOMatType::const_iterator Nektar::COOMatTypeConstIt

Definition at line 57 of file SparseMatrixFwd.hpp.

◆ COOMatTypeSharedPtr

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

Definition at line 58 of file SparseMatrixFwd.hpp.

◆ COOMatVector

typedef Array<OneD, COOMatType> Nektar::COOMatVector

Definition at line 59 of file SparseMatrixFwd.hpp.

◆ CoordType

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

Definition at line 54 of file SparseMatrixFwd.hpp.

◆ CoupledAssemblyMapSharedPtr

typedef std::shared_ptr<CoupledAssemblyMap> Nektar::CoupledAssemblyMapSharedPtr

Definition at line 62 of file CoupledAssemblyMap.h.

◆ CoupledLocalToGlobalC0ContMapSharedPtr

typedef std::shared_ptr<CoupledLocalToGlobalC0ContMap> Nektar::CoupledLocalToGlobalC0ContMapSharedPtr

Definition at line 66 of file CoupledLocalToGlobalC0ContMap.h.

◆ CoupledSolverMatrices

typedef struct Nektar::coupledSolverMatrices Nektar::CoupledSolverMatrices

◆ DenseMatrix

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DenseMatrix

Definition at line 51 of file NekTypeDefs.hpp.

◆ DiffusionLDGNSSharedPtr

typedef std::shared_ptr<DiffusionLDGNS> Nektar::DiffusionLDGNSSharedPtr

Definition at line 163 of file DiffusionLDGNS.h.

◆ DNekBlkMat

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

Definition at line 58 of file NekTypeDefs.hpp.

◆ DNekBlkMatSharedPtr

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

Definition at line 77 of file NekTypeDefs.hpp.

◆ DNekLinSys

typedef LinearSystem Nektar::DNekLinSys

Definition at line 87 of file NekTypeDefs.hpp.

◆ DNekLinSysSharedPtr

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

Definition at line 88 of file NekTypeDefs.hpp.

◆ DNekMat

typedef NekMatrix<NekDouble, StandardMatrixTag> Nektar::DNekMat

Definition at line 50 of file NekTypeDefs.hpp.

◆ DNekMatSharedPtr

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

Definition at line 75 of file NekTypeDefs.hpp.

◆ DNekScalBlkMat

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

Definition at line 68 of file NekTypeDefs.hpp.

◆ DNekScalBlkMatSharedPtr

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

Definition at line 79 of file NekTypeDefs.hpp.

◆ DNekScalLinSys

typedef LinearSystem Nektar::DNekScalLinSys

Definition at line 90 of file NekTypeDefs.hpp.

◆ DNekScalLinSysSharedPtr

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

Definition at line 91 of file NekTypeDefs.hpp.

◆ DNekScalMat

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

Definition at line 65 of file NekMatrixFwd.hpp.

◆ DNekScalMatSharedPtr

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

Definition at line 66 of file NekMatrixFwd.hpp.

◆ DNekVec

typedef NekVector<NekDouble> Nektar::DNekVec

Definition at line 48 of file NekTypeDefs.hpp.

◆ EmpiricalPressureAreaSharedPtr

typedef std::shared_ptr<EmpiricalPressureArea> Nektar::EmpiricalPressureAreaSharedPtr

Definition at line 49 of file EmpiricalPressureArea.h.

◆ EquationOfStateFactory

typedef LibUtilities::NekFactory<std::string, EquationOfState, const LibUtilities::SessionReaderSharedPtr &> Nektar::EquationOfStateFactory

Declaration of the equation of state factory.

Definition at line 54 of file EquationOfState.h.

◆ EquationOfStateSharedPtr

typedef std::shared_ptr<EquationOfState> Nektar::EquationOfStateSharedPtr

A shared pointer to an equation of state object.

Definition at line 49 of file EquationOfState.h.

◆ ExtrapolateFactory

typedef LibUtilities::NekFactory< std::string, Extrapolate, const LibUtilities::SessionReaderSharedPtr &, Array<OneD, MultiRegions::ExpListSharedPtr> &, MultiRegions::ExpListSharedPtr &, const Array<OneD, int> &, const SolverUtils::AdvectionSharedPtr &> Nektar::ExtrapolateFactory

Definition at line 66 of file Extrapolate.h.

◆ ExtrapolateSharedPtr

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

Definition at line 60 of file Extrapolate.h.

◆ FilterAeroForcesSPMSharedPtr

typedef std::shared_ptr<FilterAeroForcesSPM> Nektar::FilterAeroForcesSPMSharedPtr

Definition at line 105 of file FilterAeroForcesSPM.h.

◆ FilterMap

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

Definition at line 48 of file FilterMovingBody.h.

◆ FilterMovingBodySharedPtr

typedef std::shared_ptr<FilterMovingBody> Nektar::FilterMovingBodySharedPtr

Definition at line 46 of file FilterMovingBody.h.

◆ FilterParams

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

Definition at line 47 of file FilterMovingBody.h.

◆ HighOrderOutflowSharedPtr

typedef std::shared_ptr<HighOrderOutflow> Nektar::HighOrderOutflowSharedPtr

Definition at line 69 of file Extrapolate.h.

◆ ImplicitExtrapolateSharedPtr

typedef std::shared_ptr<ImplicitExtrapolate> Nektar::ImplicitExtrapolateSharedPtr

Definition at line 53 of file ImplicitExtrapolate.h.

◆ IncBaseConditionSharedPtr

typedef std::shared_ptr<IncBaseCondition> Nektar::IncBaseConditionSharedPtr

Definition at line 53 of file IncBaseCondition.h.

◆ IncBCFactory

typedef LibUtilities::NekFactory< std::string, IncBaseCondition, const LibUtilities::SessionReaderSharedPtr, Array<OneD, MultiRegions::ExpListSharedPtr>, Array<OneD, SpatialDomains::BoundaryConditionShPtr>, Array<OneD, MultiRegions::ExpListSharedPtr>, int, int, int> Nektar::IncBCFactory

Definition at line 60 of file IncBaseCondition.h.

◆ IncBoundaryConditionsSharedPtr

typedef std::shared_ptr<IncBoundaryConditions> Nektar::IncBoundaryConditionsSharedPtr

Definition at line 47 of file IncBoundaryConditions.h.

◆ IncNavierStokesSharedPtr

typedef std::shared_ptr<IncNavierStokes> Nektar::IncNavierStokesSharedPtr

Definition at line 300 of file IncNavierStokes.h.

◆ IndexType

typedef unsigned int Nektar::IndexType

Definition at line 49 of file SparseMatrixFwd.hpp.

◆ IndexVector

typedef Array<OneD, IndexType> Nektar::IndexVector

Definition at line 51 of file SparseMatrixFwd.hpp.

◆ InterfacePointShPtr

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

Definition at line 74 of file PulseWaveSystem.h.

◆ MappingExtrapolateSharedPtr

typedef std::shared_ptr<MappingExtrapolate> Nektar::MappingExtrapolateSharedPtr

Definition at line 49 of file MappingExtrapolate.h.

◆ MetricSharedPtr

typedef std::shared_ptr<Metric> Nektar::MetricSharedPtr

A shared pointer to an EquationSystem object.

Definition at line 124 of file Metric.h.

◆ NekComplexDouble

typedef std::complex<double> Nektar::NekComplexDouble

Definition at line 113 of file IncNavierStokes.h.

◆ NekDouble

typedef double Nektar::NekDouble

Definition at line 43 of file NektarUnivTypeDefs.hpp.

◆ NekInt

typedef std::int32_t Nektar::NekInt

Definition at line 46 of file NektarUnivTypeDefs.hpp.

◆ NekInt32

typedef std::int32_t Nektar::NekInt32

Definition at line 47 of file NektarUnivTypeDefs.hpp.

◆ NekInt64

typedef std::int64_t Nektar::NekInt64

Definition at line 48 of file NektarUnivTypeDefs.hpp.

◆ NekSingle

typedef float Nektar::NekSingle

Definition at line 44 of file NektarUnivTypeDefs.hpp.

◆ NekUInt

typedef std::uint32_t Nektar::NekUInt

Definition at line 49 of file NektarUnivTypeDefs.hpp.

◆ NekUInt32

typedef std::uint32_t Nektar::NekUInt32

Definition at line 50 of file NektarUnivTypeDefs.hpp.

◆ NekUInt64

typedef std::uint64_t Nektar::NekUInt64

Definition at line 51 of file NektarUnivTypeDefs.hpp.

◆ PowerPressureAreaSharedPtr

typedef std::shared_ptr<PowerPressureArea> Nektar::PowerPressureAreaSharedPtr

Definition at line 49 of file PowerPressureArea.h.

◆ PreconCfsFactory

typedef LibUtilities::NekFactory< std::string, PreconCfs, const Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &, const LibUtilities::CommSharedPtr &> Nektar::PreconCfsFactory

Declaration of the boundary condition factory.

Definition at line 54 of file PreconCfs.h.

◆ PreconCfsSharedPtr

typedef std::shared_ptr<PreconCfs> Nektar::PreconCfsSharedPtr

Definition at line 112 of file PreconCfs.h.

◆ PressureAreaFactory

typedef LibUtilities::NekFactory<std::string, PulseWavePressureArea, Array<OneD, MultiRegions::ExpListSharedPtr> &, const LibUtilities::SessionReaderSharedPtr &> Nektar::PressureAreaFactory

Definition at line 56 of file PulseWavePressureArea.h.

◆ ProtocolFactory

typedef LibUtilities::NekFactory<std::string, Protocol, const LibUtilities::SessionReaderSharedPtr &, const TiXmlElement *> Nektar::ProtocolFactory

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

Definition at line 56 of file Protocol.h.

◆ ProtocolSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 49 of file Protocol.h.

◆ PulseWaveBoundarySharedPtr

typedef std::shared_ptr<PulseWaveBoundary> Nektar::PulseWaveBoundarySharedPtr

Definition at line 50 of file PulseWaveBoundary.h.

◆ PulseWavePressureAreaSharedPtr

typedef std::shared_ptr<PulseWavePressureArea> Nektar::PulseWavePressureAreaSharedPtr

Definition at line 49 of file PulseWavePressureArea.h.

◆ PulseWaveSystemSharedPtr

typedef std::shared_ptr<PulseWaveSystem> Nektar::PulseWaveSystemSharedPtr

Definition at line 211 of file PulseWaveSystem.h.

◆ QInflowSharedPtr

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

Definition at line 49 of file QInflow.h.

◆ RawType_t

template<typename T >

using Nektar::RawType_t = typedef typename RawType<T>::type

Definition at line 70 of file RawType.hpp.

◆ RCROutflowSharedPtr

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

Definition at line 49 of file RCROutflow.h.

◆ ROutflowSharedPtr

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

Definition at line 49 of file ROutflow.h.

◆ SBlockMatrix

typedef NekMatrix<SDenseMatrix, BlockMatrixTag> Nektar::SBlockMatrix

Definition at line 106 of file NekTypeDefs.hpp.

◆ ScaledMatrix

typedef NekMatrix<DenseMatrix, ScaledMatrixTag> Nektar::ScaledMatrix

Definition at line 55 of file NekTypeDefs.hpp.

◆ SDenseMatrix

typedef NekMatrix<NekSingle, StandardMatrixTag> Nektar::SDenseMatrix

Definition at line 98 of file NekTypeDefs.hpp.

◆ SharedNekMatrixPtr

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

Definition at line 63 of file NekMatrixFwd.hpp.

◆ SharedSNekMatrixPtr

typedef std::shared_ptr<NekMatrix<NekSingle, StandardMatrixTag> > Nektar::SharedSNekMatrixPtr

Definition at line 69 of file NekMatrixFwd.hpp.

◆ SmoothedProfileMethodSharedPtr

typedef std::shared_ptr<SmoothedProfileMethod> Nektar::SmoothedProfileMethodSharedPtr

Definition at line 162 of file SmoothedProfileMethod.h.

◆ SNekBlkMat

typedef NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, BlockMatrixTag> Nektar::SNekBlkMat

Definition at line 105 of file NekTypeDefs.hpp.

◆ SNekBlkMatSharedPtr

typedef std::shared_ptr<SNekBlkMat> Nektar::SNekBlkMatSharedPtr

Definition at line 124 of file NekTypeDefs.hpp.

◆ SNekMat

Nektar::SNekMat

Definition at line 97 of file NekTypeDefs.hpp.

◆ SNekMatSharedPtr

typedef std::shared_ptr<SNekMat> Nektar::SNekMatSharedPtr

Definition at line 122 of file NekTypeDefs.hpp.

◆ SNekScalBlkMat

typedef NekMatrix< NekMatrix<NekMatrix<NekSingle, StandardMatrixTag>, ScaledMatrixTag>, BlockMatrixTag> Nektar::SNekScalBlkMat

Definition at line 115 of file NekTypeDefs.hpp.

◆ SNekScalBlkMatSharedPtr

typedef std::shared_ptr<SNekScalBlkMat> Nektar::SNekScalBlkMatSharedPtr

Definition at line 126 of file NekTypeDefs.hpp.

◆ SNekScalMat

typedef NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > Nektar::SNekScalMat

Definition at line 71 of file NekMatrixFwd.hpp.

◆ SNekScalMatSharedPtr

typedef std::shared_ptr< SNekScalMat > Nektar::SNekScalMatSharedPtr

Definition at line 72 of file NekMatrixFwd.hpp.

◆ SNekVec

typedef NekVector<NekSingle> Nektar::SNekVec

Definition at line 95 of file NekTypeDefs.hpp.

◆ SScaledMatrix

typedef NekMatrix<SDenseMatrix, ScaledMatrixTag> Nektar::SScaledMatrix

Definition at line 102 of file NekTypeDefs.hpp.

◆ StandardExtrapolateSharedPtr

typedef std::shared_ptr<StandardExtrapolate> Nektar::StandardExtrapolateSharedPtr

Definition at line 55 of file StandardExtrapolate.h.

◆ StimulusFactory

typedef LibUtilities::NekFactory< std::string, Stimulus, const LibUtilities::SessionReaderSharedPtr &, const MultiRegions::ExpListSharedPtr &, const TiXmlElement *> Nektar::StimulusFactory

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

Definition at line 59 of file Stimulus.h.

◆ StimulusSharedPtr

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

A shared pointer to an EquationSystem object.

Definition at line 52 of file Stimulus.h.

◆ SubSteppingExtrapolateSharedPtr

typedef std::shared_ptr<SubSteppingExtrapolate> Nektar::SubSteppingExtrapolateSharedPtr

Definition at line 55 of file SubSteppingExtrapolate.h.

◆ SubSteppingExtrapolateWeakPressureSharedPtr

typedef std::shared_ptr<SubSteppingExtrapolateWeakPressure> Nektar::SubSteppingExtrapolateWeakPressureSharedPtr

Definition at line 49 of file SubSteppingExtrapolateWeakPressure.h.

◆ SummaryList

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

Definition at line 52 of file CellModel.h.

◆ TemplatePressureAreaSharedPtr

typedef std::shared_ptr<TemplatePressureArea> Nektar::TemplatePressureAreaSharedPtr

Definition at line 47 of file TemplatePressureArea.h.

◆ TensorOfArray2D

template<class T >

using Nektar::TensorOfArray2D = typedef Array<OneD, Array<OneD, T> >

Definition at line 933 of file BasicUtils/SharedArray.hpp.

◆ TensorOfArray3D

template<class T >

using Nektar::TensorOfArray3D = typedef Array<OneD, Array<OneD, Array<OneD, T> >>

Definition at line 938 of file BasicUtils/SharedArray.hpp.

◆ TensorOfArray4D

template<class T >

using Nektar::TensorOfArray4D = typedef Array<OneD, Array<OneD, Array<OneD, Array<OneD, T> >> >

Definition at line 943 of file BasicUtils/SharedArray.hpp.

◆ TensorOfArray5D

template<class T >

using Nektar::TensorOfArray5D = typedef Array<OneD, Array<OneD, Array<OneD, Array<OneD, Array<OneD, T> >> >>

Definition at line 948 of file BasicUtils/SharedArray.hpp.

◆ TerminalOutflowSharedPtr

typedef std::shared_ptr<TerminalOutflow> Nektar::TerminalOutflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 49 of file TerminalOutflow.h.

◆ TimeDependentInflowSharedPtr

typedef std::shared_ptr<TimeDependentInflow> Nektar::TimeDependentInflowSharedPtr

Definition at line 49 of file TimeDependentInflow.h.

◆ UInflowSharedPtr

typedef std::shared_ptr<UInflow> Nektar::UInflowSharedPtr

Pointer to a PulseWaveOutflow object.

Definition at line 48 of file UInflow.h.

◆ UndefinedInOutflowSharedPtr

typedef std::shared_ptr<UndefinedInOutflow> Nektar::UndefinedInOutflowSharedPtr

Definition at line 49 of file UndefinedInOutflow.h.

◆ VariableConverterSharedPtr

typedef std::shared_ptr<VariableConverter> Nektar::VariableConverterSharedPtr

Definition at line 47 of file VariableConverter.h.

◆ VCSImplicitSharedPtr

typedef std::shared_ptr<VCSImplicit> Nektar::VCSImplicitSharedPtr

Definition at line 125 of file VelocityCorrectionSchemeImplicit.h.

◆ VCSMappingSharedPtr

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

Definition at line 155 of file VCSMapping.h.

◆ VCSWeakPressureSharedPtr

typedef std::shared_ptr<VCSWeakPressure> Nektar::VCSWeakPressureSharedPtr

Definition at line 99 of file VelocityCorrectionSchemeWeakPressure.h.

◆ vec_t

using Nektar::vec_t = typedef tinysimd::simd<NekDouble>

Definition at line 59 of file EquationOfState.h.

◆ VelocityCorrectionSchemeSharedPtr

typedef std::shared_ptr<VelocityCorrectionScheme> Nektar::VelocityCorrectionSchemeSharedPtr

Definition at line 246 of file VelocityCorrectionScheme.h.

◆ WeakPressureExtrapolateSharedPtr

typedef std::shared_ptr<WeakPressureExtrapolate> Nektar::WeakPressureExtrapolateSharedPtr

Definition at line 56 of file WeakPressureExtrapolate.h.

◆ WomersleyParamsSharedPtr

typedef std::shared_ptr<WomersleyParams> Nektar::WomersleyParamsSharedPtr

Definition at line 140 of file IncNavierStokes.h.

Enumeration Type Documentation

◆ AdvectionForm

enum Nektar::AdvectionForm

Enumerator
eNoAdvectionForm
eConvective
eNonConservative
eLinearised
eAdjoint
eSkewSymmetric
eNoAdvection
eAdvectionFormSize

Definition at line 92 of file IncNavierStokes.h.

{
    eNoAdvectionForm,
    eConvective,
    eNonConservative,
    eLinearised,
    eAdjoint,
    eSkewSymmetric,
    eNoAdvection,
    eAdvectionFormSize
};

◆ ArrayWrapperType

enum Nektar::ArrayWrapperType

Enumerator
eArrayCopy
eArrayWrapper

Definition at line 50 of file BasicUtils/SharedArray.hpp.

{
    eArrayCopy,
    eArrayWrapper
};

◆ CommandType

enum Nektar::CommandType

Enumerator
eNone
eSequential
eParallel

Definition at line 57 of file TestData.h.

{
    eNone,
    eSequential,
    eParallel
};

◆ Direction

enum Nektar::Direction

Enumerator
xDir
yDir
zDir

Definition at line 71 of file NektarUnivTypeDefs.hpp.

{
    xDir = 0,
    yDir = 1,
    zDir = 2
};

◆ EquationType

enum Nektar::EquationType

Enumerator
eNoEquationType
eSteadyStokes
eSteadyOseen
eSteadyLinearisedNS
eUnsteadyStokes
eUnsteadyLinearisedNS
eUnsteadyNavierStokes
eSteadyNavierStokes
eEquationTypeSize

Definition at line 67 of file IncNavierStokes.h.

{
    eNoEquationType,
    eSteadyStokes,
    eSteadyOseen,
    eSteadyLinearisedNS,
    eUnsteadyStokes,
    eUnsteadyLinearisedNS,
    eUnsteadyNavierStokes,
    eSteadyNavierStokes,
    eEquationTypeSize
};

◆ FlagType

enum Nektar::FlagType

Enumeration of flags for passing a list of options.

Enumerator
eUseGlobal

Definition at line 89 of file NektarUnivTypeDefs.hpp.

{
    eUseGlobal
};

◆ HBCType

enum Nektar::HBCType

Enumerator
eNOHBC
eHBCNeumann
eOBC
eConvectiveOBC

Definition at line 50 of file Extrapolate.h.

{
    eNOHBC,
    eHBCNeumann, // Standard High Order BC
    eOBC, // High Order outflow BC (Neumann-Dirichlet) from Dong et al JCP 2014
    eConvectiveOBC // Convective High Order (Robin type) BC from Dong JCP 2015
};

◆ InitWaveType

enum Nektar::InitWaveType

Enumerator
eLeft
eBothEnds
eCenter
eLeftBottomCorner
ePoint
eSpiralDock
SIZE_InitWaveType	Length of enum list.

Definition at line 63 of file MMFDiffusion.h.

{
    eLeft,
    eBothEnds,
    eCenter,
    eLeftBottomCorner,
    ePoint,
    eSpiralDock,
    SIZE_InitWaveType ///< Length of enum list
};

◆ MatrixStorage

enum Nektar::MatrixStorage

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 41 of file MatrixStorageType.h.

{
    eFULL,
    eDIAGONAL,
    eUPPER_TRIANGULAR,
    eLOWER_TRIANGULAR,
    eSYMMETRIC,
    ePOSITIVE_DEFINITE_SYMMETRIC,
    eBANDED,
    eSYMMETRIC_BANDED,
    ePOSITIVE_DEFINITE_SYMMETRIC_BANDED,
    eUPPER_TRIANGULAR_BANDED,
    eLOWER_TRIANGULAR_BANDED
};

◆ OutputFormat

enum Nektar::OutputFormat

Enumeration a flags for output format.

Enumerator
eTecplot
eTecplotZones
eTecplotSingleBlock
eGmsh
eGnuplot

Definition at line 79 of file NektarUnivTypeDefs.hpp.

{
    eTecplot,
    eTecplotZones,
    eTecplotSingleBlock,
    eGmsh,
    eGnuplot
};

◆ PointerWrapper

enum Nektar::PointerWrapper

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.

{
    eWrapper,
    eCopy
};

◆ ProblemType

enum Nektar::ProblemType

Enumerator
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 NonlinearPeregrine.h.

{
    eGeneral,        ///< No problem defined - Default Inital data
    eSolitaryWave,   ///< First order Laitone solitary wave
    SIZE_ProblemType ///< Length of enum list
};

◆ SolverType

enum Nektar::SolverType

Enumerator
eNoSolverType
eCoupledLinearisedNS
eSmoothedProfileMethod
eVCSMapping
eVelocityCorrectionScheme
eVCSWeakPressure
eWeakPressure
eVCSImplicit
eImplicit

Definition at line 54 of file IncNavierStokes.h.

{
    eNoSolverType,
    eCoupledLinearisedNS,
    eSmoothedProfileMethod,
    eVCSMapping,
    eVelocityCorrectionScheme,
    eVCSWeakPressure,
    eWeakPressure,
    eVCSImplicit,
    eImplicit,
};

◆ TestType [1/2]

enum Nektar::TestType

Enumerator
eTestPlane
eTestCube
eTestLinearSphere
eTestNonlinearSphere
eFHNStandard
eFHNRogers
eFHNAlievPanf
SIZE_TestType	Length of enum list.
eTestPlane
eTestSteadyZonal
eTestUnsteadyZonal
eTestIsolatedMountain
eTestUnstableJet
eTestRossbyWave
SIZE_TestType	Length of enum list.

Definition at line 46 of file MMFDiffusion.h.

{
    eTestPlane,
    eTestCube,
    eTestLinearSphere,
    eTestNonlinearSphere,
    eFHNStandard,
    eFHNRogers,
    eFHNAlievPanf,
    SIZE_TestType ///< Length of enum list
};

◆ TestType [2/2]

enum Nektar::TestType

Enumerator
eTestPlane
eTestCube
eTestLinearSphere
eTestNonlinearSphere
eFHNStandard
eFHNRogers
eFHNAlievPanf
SIZE_TestType	Length of enum list.
eTestPlane
eTestSteadyZonal
eTestUnsteadyZonal
eTestIsolatedMountain
eTestUnstableJet
eTestRossbyWave
SIZE_TestType	Length of enum list.

Definition at line 43 of file MMFSWE.h.

{
    eTestPlane,
    eTestSteadyZonal,
    eTestUnsteadyZonal,
    eTestIsolatedMountain,
    eTestUnstableJet,
    eTestRossbyWave,
    SIZE_TestType ///< Length of enum list
};

◆ UpwindTypePulse

enum Nektar::UpwindTypePulse

Enumerator
eNotSetPulse	flux not defined
eUpwindPulse	simple upwinding scheme
SIZE_UpwindTypePulse	Length of enum list.

Definition at line 47 of file PulseWaveSystem.h.

{
    eNotSetPulse,        ///< flux not defined
    eUpwindPulse,        ///< simple upwinding scheme
    SIZE_UpwindTypePulse ///< Length of enum list
};

◆ VWIIterationType

enum Nektar::VWIIterationType

Enumerator
eFixedAlpha
eFixedWaveForcing
eFixedAlphaWaveForcing
eFixedWaveForcingWithSubIterationOnAlpha
eVWIIterationTypeSize

Definition at line 53 of file VortexWaveInteraction.h.

{
    eFixedAlpha,
    eFixedWaveForcing,
    eFixedAlphaWaveForcing,
    eFixedWaveForcingWithSubIterationOnAlpha,
    eVWIIterationTypeSize
};

Function Documentation

◆ Add() [1/10]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Add	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 335 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    lhs.GetColumns());
    Add(result, lhs, rhs);
    return result;
}

References Add().

◆ Add() [2/10]

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 335 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    lhs.GetColumns());
    Add(result, lhs, rhs);
    return result;
}

References Add().

◆ Add() [3/10]

template<typename LhsDataType , typename RhsDataType >

NekVector< LhsDataType > Nektar::Add	(	const NekVector< LhsDataType > &	lhs,
		const NekVector< RhsDataType > &	rhs
	)

Definition at line 561 of file NekVector.cpp.

{
    NekVector<LhsDataType> result(lhs.GetDimension());
    Add(result, lhs, rhs);
    return result;
}

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

◆ Add() [4/10]

template NekVector< NekDouble > Nektar::Add	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Add() [5/10]

template NekVector< NekSingle > Nektar::Add	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Referenced by Add().

◆ Add() [6/10]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 268 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(lhs.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(lhs.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(lhs.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            result(i, j) = lhs(i, j) + rhs(i, j);
        }
    }
}

References ASSERTL1.

Referenced by Add(), and operator+().

◆ Add() [7/10]

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 268 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(lhs.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(lhs.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(lhs.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            result(i, j) = lhs(i, j) + rhs(i, j);
        }
    }
}

References ASSERTL1.

Referenced by Add(), and operator+().

◆ Add() [8/10]

template<typename DataType >

void Nektar::Add	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 484 of file NekVector.cpp.

{
    DataType *r_buf         = result.GetRawPtr();
    const DataType *lhs_buf = lhs.GetRawPtr();
    const DataType *rhs_buf = rhs.GetRawPtr();
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] + rhs_buf[i];
    }
}

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

◆ Add() [9/10]

template void Nektar::Add	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Add() [10/10]

template void Nektar::Add	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ AddEqual() [1/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat void Nektar::AddEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 207 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) += rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ AddEqual() [2/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::AddEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 207 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) += rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ AddEqual() [3/5]

template<typename DataType >

void Nektar::AddEqual	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	rhs
	)

Definition at line 526 of file NekVector.cpp.

{
    DataType *r_buf         = result.GetRawPtr();
    const DataType *rhs_buf = rhs.GetRawPtr();
    const unsigned int rdim = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] += rhs_buf[i];
    }
}

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

◆ AddEqual() [4/5]

template void Nektar::AddEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

◆ AddEqual() [5/5]

template void Nektar::AddEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

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

◆ AddEqualNegatedLhs() [1/4]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::AddEqualNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 231 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) = -result(i, j) + rhs(i, j);
        }
    }
}

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

◆ AddEqualNegatedLhs() [2/4]

template<typename DataType >

void Nektar::AddEqualNegatedLhs	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	rhs
	)

Definition at line 538 of file NekVector.cpp.

{
    DataType *r_buf         = result.GetRawPtr();
    const DataType *rhs_buf = rhs.GetRawPtr();
    const unsigned int rdim = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] = -r_buf[i] + rhs_buf[i];
    }
}

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

◆ AddEqualNegatedLhs() [3/4]

template void Nektar::AddEqualNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

◆ AddEqualNegatedLhs() [4/4]

template void Nektar::AddEqualNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

◆ AddNegatedLhs() [1/4]

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 294 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(lhs.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be added."));
    ASSERTL1(lhs.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(lhs.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be added."));
 
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            result(i, j) = -lhs(i, j) + rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ AddNegatedLhs() [2/4]

template<typename DataType >

void Nektar::AddNegatedLhs	(	NekVector< DataType > &	result,
		const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 498 of file NekVector.cpp.

{
    DataType *r_buf         = result.GetRawPtr();
    const DataType *lhs_buf = lhs.GetRawPtr();
    const DataType *rhs_buf = rhs.GetRawPtr();
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = -lhs_buf[i] + rhs_buf[i];
    }
}

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

◆ AddNegatedLhs() [3/4]

template void Nektar::AddNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ AddNegatedLhs() [4/4]

template void Nektar::AddNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ AsString() [1/3]

template<typename DataType >

std::string Nektar::AsString ( const NekVector< DataType > & v )

Definition at line 1266 of file NekVector.cpp.

{
    unsigned int d     = v.GetRows();
    std::string result = "(";
    for (unsigned int i = 0; i < d; ++i)
    {
        result += boost::lexical_cast<std::string>(v[i]);
        if (i < v.GetDimension() - 1)
        {
            result += ", ";
        }
    }
    result += ")";
    return result;
}

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

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

◆ AsString() [2/3]

template std::string Nektar::AsString ( const NekVector< NekDouble > & v )

◆ AsString() [3/3]

template std::string Nektar::AsString ( const NekVector< NekSingle > & v )

◆ BOOST_AUTO_TEST_CASE() [1/3]

Nektar::BOOST_AUTO_TEST_CASE ( TestABPlusbCBlock )

Definition at line 104 of file TestDgemmOptimizations.cpp.

{
    typedef NekMatrix<NekMatrix<double>, BlockMatrixTag> BlockMatrix;
 
    double abuf[] = {1, 2, 3, 4};
    double bbuf[] = {5, 6, 7, 8};
    double cbuf[] = {9, 10, 11, 12};
    double dbuf[] = {13, 14, 15, 16};
    double beta   = 7.0;
    double alpha  = 2.0;
 
    std::shared_ptr<NekMatrix<double>> innerA(
        new NekMatrix<double>(2, 2, abuf));
    std::shared_ptr<NekMatrix<double>> innerB(
        new NekMatrix<double>(2, 2, bbuf));
    std::shared_ptr<NekMatrix<double>> innerC(
        new NekMatrix<double>(2, 2, cbuf));
    std::shared_ptr<NekMatrix<double>> innerD(
        new NekMatrix<double>(2, 2, dbuf));
 
    BlockMatrix A(2, 2, 2, 2);
    BlockMatrix B(2, 2, 2, 2);
    BlockMatrix C(2, 2, 2, 2);
 
    A.SetBlock(0, 0, innerA);
    A.SetBlock(0, 1, innerB);
    A.SetBlock(1, 0, innerC);
    A.SetBlock(1, 1, innerD);
 
    B.SetBlock(0, 0, innerA);
    B.SetBlock(0, 1, innerB);
    B.SetBlock(1, 0, innerC);
    B.SetBlock(1, 1, innerD);
 
    C.SetBlock(0, 0, innerA);
    C.SetBlock(0, 1, innerB);
    C.SetBlock(1, 0, innerC);
    C.SetBlock(1, 1, innerD);
    double epsilon = 1e-11;
 
    NekMatrix<double> result1     = A * B + C;
    double expected_result_buf1[] = {123, 146, 307, 330, 157, 188, 405, 436,
                                     191, 230, 503, 542, 225, 272, 601, 648};
    NekMatrix<double> expected_result1(4, 4, expected_result_buf1);
    BOOST_CHECK_EQUAL(expected_result1, result1);
 
    NekMatrix<double> result2 = A * B + beta * C;
    BOOST_CHECK_CLOSE(129.0, *result2(0, 0), epsilon);
    BOOST_CHECK_CLOSE(158.0, *result2(1, 0), epsilon);
    BOOST_CHECK_CLOSE(361.0, *result2(2, 0), epsilon);
    BOOST_CHECK_CLOSE(390.0, *result2(3, 0), epsilon);
    BOOST_CHECK_CLOSE(175.0, *result2(0, 1), epsilon);
    BOOST_CHECK_CLOSE(212.0, *result2(1, 1), epsilon);
    BOOST_CHECK_CLOSE(471.0, *result2(2, 1), epsilon);
    BOOST_CHECK_CLOSE(508.0, *result2(3, 1), epsilon);
    BOOST_CHECK_CLOSE(221.0, *result2(0, 2), epsilon);
    BOOST_CHECK_CLOSE(266.0, *result2(1, 2), epsilon);
    BOOST_CHECK_CLOSE(581.0, *result2(2, 2), epsilon);
    BOOST_CHECK_CLOSE(626.0, *result2(3, 2), epsilon);
    BOOST_CHECK_CLOSE(267.0, *result2(0, 3), epsilon);
    BOOST_CHECK_CLOSE(320.0, *result2(1, 3), epsilon);
    BOOST_CHECK_CLOSE(691.0, *result2(2, 3), epsilon);
    BOOST_CHECK_CLOSE(744.0, *result2(3, 3), epsilon);
 
    NekMatrix<double> result3 = alpha * A * B + C;
    BOOST_CHECK_CLOSE(245.0, *result3(0, 0), epsilon);
    BOOST_CHECK_CLOSE(290.0, *result3(1, 0), epsilon);
    BOOST_CHECK_CLOSE(605.0, *result3(2, 0), epsilon);
    BOOST_CHECK_CLOSE(650.0, *result3(3, 0), epsilon);
    BOOST_CHECK_CLOSE(311.0, *result3(0, 1), epsilon);
    BOOST_CHECK_CLOSE(372.0, *result3(1, 1), epsilon);
    BOOST_CHECK_CLOSE(799.0, *result3(2, 1), epsilon);
    BOOST_CHECK_CLOSE(860.0, *result3(3, 1), epsilon);
    BOOST_CHECK_CLOSE(377.0, *result3(0, 2), epsilon);
    BOOST_CHECK_CLOSE(454.0, *result3(1, 2), epsilon);
    BOOST_CHECK_CLOSE(993.0, *result3(2, 2), epsilon);
    BOOST_CHECK_CLOSE(1070.0, *result3(3, 2), epsilon);
    BOOST_CHECK_CLOSE(443.0, *result3(0, 3), epsilon);
    BOOST_CHECK_CLOSE(536.0, *result3(1, 3), epsilon);
    BOOST_CHECK_CLOSE(1187.0, *result3(2, 3), epsilon);
    BOOST_CHECK_CLOSE(1280.0, *result3(3, 3), epsilon);
 
    NekMatrix<double> result4 = alpha * A * B + beta * C;
    BOOST_CHECK_CLOSE(251.0, *result4(0, 0), epsilon);
    BOOST_CHECK_CLOSE(302.0, *result4(1, 0), epsilon);
    BOOST_CHECK_CLOSE(659.0, *result4(2, 0), epsilon);
    BOOST_CHECK_CLOSE(710.0, *result4(3, 0), epsilon);
    BOOST_CHECK_CLOSE(329.0, *result4(0, 1), epsilon);
    BOOST_CHECK_CLOSE(396.0, *result4(1, 1), epsilon);
    BOOST_CHECK_CLOSE(865.0, *result4(2, 1), epsilon);
    BOOST_CHECK_CLOSE(932.0, *result4(3, 1), epsilon);
    BOOST_CHECK_CLOSE(407.0, *result4(0, 2), epsilon);
    BOOST_CHECK_CLOSE(490.0, *result4(1, 2), epsilon);
    BOOST_CHECK_CLOSE(1071.0, *result4(2, 2), epsilon);
    BOOST_CHECK_CLOSE(1154.0, *result4(3, 2), epsilon);
    BOOST_CHECK_CLOSE(485.0, *result4(0, 3), epsilon);
    BOOST_CHECK_CLOSE(584.0, *result4(1, 3), epsilon);
    BOOST_CHECK_CLOSE(1277.0, *result4(2, 3), epsilon);
    BOOST_CHECK_CLOSE(1376.0, *result4(3, 3), epsilon);
 
    NekMatrix<double> result5 = alpha * (A * B) + C;
    BOOST_CHECK_CLOSE(245.0, *result5(0, 0), epsilon);
    BOOST_CHECK_CLOSE(290.0, *result5(1, 0), epsilon);
    BOOST_CHECK_CLOSE(605.0, *result5(2, 0), epsilon);
    BOOST_CHECK_CLOSE(650.0, *result5(3, 0), epsilon);
    BOOST_CHECK_CLOSE(311.0, *result5(0, 1), epsilon);
    BOOST_CHECK_CLOSE(372.0, *result5(1, 1), epsilon);
    BOOST_CHECK_CLOSE(799.0, *result5(2, 1), epsilon);
    BOOST_CHECK_CLOSE(860.0, *result5(3, 1), epsilon);
    BOOST_CHECK_CLOSE(377.0, *result5(0, 2), epsilon);
    BOOST_CHECK_CLOSE(454.0, *result5(1, 2), epsilon);
    BOOST_CHECK_CLOSE(993.0, *result5(2, 2), epsilon);
    BOOST_CHECK_CLOSE(1070.0, *result5(3, 2), epsilon);
    BOOST_CHECK_CLOSE(443.0, *result5(0, 3), epsilon);
    BOOST_CHECK_CLOSE(536.0, *result5(1, 3), epsilon);
    BOOST_CHECK_CLOSE(1187.0, *result5(2, 3), epsilon);
    BOOST_CHECK_CLOSE(1280.0, *result5(3, 3), epsilon);
 
    NekMatrix<double> result6 = alpha * (A * B) + beta * C;
    BOOST_CHECK_CLOSE(251.0, *result6(0, 0), epsilon);
    BOOST_CHECK_CLOSE(302.0, *result6(1, 0), epsilon);
    BOOST_CHECK_CLOSE(659.0, *result6(2, 0), epsilon);
    BOOST_CHECK_CLOSE(710.0, *result6(3, 0), epsilon);
    BOOST_CHECK_CLOSE(329.0, *result6(0, 1), epsilon);
    BOOST_CHECK_CLOSE(396.0, *result6(1, 1), epsilon);
    BOOST_CHECK_CLOSE(865.0, *result6(2, 1), epsilon);
    BOOST_CHECK_CLOSE(932.0, *result6(3, 1), epsilon);
    BOOST_CHECK_CLOSE(407.0, *result6(0, 2), epsilon);
    BOOST_CHECK_CLOSE(490.0, *result6(1, 2), epsilon);
    BOOST_CHECK_CLOSE(1071.0, *result6(2, 2), epsilon);
    BOOST_CHECK_CLOSE(1154.0, *result6(3, 2), epsilon);
    BOOST_CHECK_CLOSE(485.0, *result6(0, 3), epsilon);
    BOOST_CHECK_CLOSE(584.0, *result6(1, 3), epsilon);
    BOOST_CHECK_CLOSE(1277.0, *result6(2, 3), epsilon);
    BOOST_CHECK_CLOSE(1376.0, *result6(3, 3), epsilon);
}

References Nektar::LibUtilities::beta.

◆ BOOST_AUTO_TEST_CASE() [2/3]

Nektar::BOOST_AUTO_TEST_CASE ( TestABPlusbCScaled )

Definition at line 45 of file TestDgemmOptimizations.cpp.

{
    typedef NekMatrix<NekMatrix<double>, ScaledMatrixTag> ScaledMatrix;
 
    double abuf[] = {1, 2, 3, 4};
    double bbuf[] = {5, 6, 7, 8};
    double cbuf[] = {9, 10, 11, 12};
    double beta   = 7.0;
    double alpha  = 2.0;
 
    std::shared_ptr<NekMatrix<double>> innerA(
        new NekMatrix<double>(2, 2, abuf));
    std::shared_ptr<NekMatrix<double>> innerB(
        new NekMatrix<double>(2, 2, bbuf));
    std::shared_ptr<NekMatrix<double>> innerC(
        new NekMatrix<double>(2, 2, cbuf));
 
    ScaledMatrix A(2.0, innerA);
    ScaledMatrix B(3.0, innerB);
    ScaledMatrix C(4.0, innerC);
    double epsilon = 1e-11;
 
    NekMatrix<double> result1 = A * B + C;
    BOOST_CHECK_CLOSE(174.0, *result1(0, 0), epsilon);
    BOOST_CHECK_CLOSE(244.0, *result1(1, 0), epsilon);
    BOOST_CHECK_CLOSE(230.0, *result1(0, 1), epsilon);
    BOOST_CHECK_CLOSE(324.0, *result1(1, 1), epsilon);
 
    NekMatrix<double> result2 = A * B + beta * C;
    BOOST_CHECK_CLOSE(390.0, *result2(0, 0), epsilon);
    BOOST_CHECK_CLOSE(484.0, *result2(1, 0), epsilon);
    BOOST_CHECK_CLOSE(494.0, *result2(0, 1), epsilon);
    BOOST_CHECK_CLOSE(612.0, *result2(1, 1), epsilon);
 
    NekMatrix<double> result3 = alpha * A * B + C;
    BOOST_CHECK_CLOSE(312.0, *result3(0, 0), epsilon);
    BOOST_CHECK_CLOSE(448.0, *result3(1, 0), epsilon);
    BOOST_CHECK_CLOSE(416.0, *result3(0, 1), epsilon);
    BOOST_CHECK_CLOSE(600.0, *result3(1, 1), epsilon);
 
    NekMatrix<double> result4 = alpha * A * B + beta * C;
    BOOST_CHECK_CLOSE(528.0, *result4(0, 0), epsilon);
    BOOST_CHECK_CLOSE(688.0, *result4(1, 0), epsilon);
    BOOST_CHECK_CLOSE(680.0, *result4(0, 1), epsilon);
    BOOST_CHECK_CLOSE(888.0, *result4(1, 1), epsilon);
 
    NekMatrix<double> result5 = alpha * (A * B) + C;
    BOOST_CHECK_CLOSE(312.0, *result5(0, 0), epsilon);
    BOOST_CHECK_CLOSE(448.0, *result5(1, 0), epsilon);
    BOOST_CHECK_CLOSE(416.0, *result5(0, 1), epsilon);
    BOOST_CHECK_CLOSE(600.0, *result5(1, 1), epsilon);
 
    NekMatrix<double> result6 = alpha * (A * B) + beta * C;
    BOOST_CHECK_CLOSE(528.0, *result6(0, 0), epsilon);
    BOOST_CHECK_CLOSE(688.0, *result6(1, 0), epsilon);
    BOOST_CHECK_CLOSE(680.0, *result6(0, 1), epsilon);
    BOOST_CHECK_CLOSE(888.0, *result6(1, 1), epsilon);
}

References Nektar::LibUtilities::beta.

◆ BOOST_AUTO_TEST_CASE() [3/3]

Nektar::BOOST_AUTO_TEST_CASE ( TestCanGetRawPtr )

Definition at line 44 of file TestCanGetRawPtr.cpp.

{
    static_assert(CanGetRawPtr<NekMatrix<double>>::value, "Should be true");
    static_assert(
        CanGetRawPtr<NekMatrix<NekMatrix<double>, ScaledMatrixTag>>::value,
        "Should be true");
    static_assert(
        !CanGetRawPtr<NekMatrix<NekMatrix<double>, BlockMatrixTag>>::value,
        "Should be false");
}

◆ convertCooToBco()

void Nektar::convertCooToBco	(	const unsigned int	blkDim,
		const COOMatType &	cooMat,
		BCOMatType &	bcoMat
	)

Definition at line 46 of file SparseUtils.cpp.

{
    COOMatTypeConstIt entry;
    BCOMatTypeConstIt blk;
    int rowcoord, localRow, blkRowCoord;
    int colcoord, localCol, blkColCoord;
 
    for (entry = cooMat.begin(); entry != cooMat.end(); entry++)
    {
        rowcoord = (entry->first).first;
        colcoord = (entry->first).second;
 
        blkRowCoord = rowcoord / blkDim;
        blkColCoord = colcoord / blkDim;
 
        CoordType blkCoords = std::make_pair(blkRowCoord, blkColCoord);
        blk                 = bcoMat.find(blkCoords);
        if (blk == bcoMat.end())
        {
            BCOEntryType b(blkDim * blkDim, 0.0);
            bcoMat[blkCoords] = b;
        }
 
        localRow = rowcoord % blkDim;
        localCol = colcoord % blkDim;
 
        // transpose it: NIST SpBLAS expects Fortran ordering
        // of dense subblocks
        const unsigned int localoffset   = localRow + localCol * blkDim;
        (bcoMat[blkCoords])[localoffset] = entry->second;
    }
}

Referenced by Nektar::MultiRegions::GlobalMatrix::GlobalMatrix().

◆ CopyArray()

template<typename ConstDataType , typename DataType >

void Nektar::CopyArray	(	const Array< OneD, ConstDataType > &	source,
		Array< OneD, DataType > &	dest
	)

Definition at line 902 of file BasicUtils/SharedArray.hpp.

{
    if (dest.size() != source.size())
    {
        dest = Array<OneD, DataType>(source.size());
    }
 
    std::copy(source.data(), source.data() + source.size(), dest.data());
}

References CellMLToNektar.pycml::copy(), Nektar::Array< OneD, DataType >::data(), and Nektar::Array< OneD, const DataType >::size().

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

◆ CopyArrayN()

template<typename ConstDataType , typename DataType >

void Nektar::CopyArrayN	(	const Array< OneD, ConstDataType > &	source,
		Array< OneD, DataType > &	dest,
		typename Array< OneD, DataType >::size_type	n
	)

Definition at line 914 of file BasicUtils/SharedArray.hpp.

{
    if (dest.size() != n)
    {
        dest = Array<OneD, DataType>(n);
    }
 
    std::copy(source.data(), source.data() + n, dest.data());
}

References CellMLToNektar.pycml::copy(), Nektar::Array< OneD, DataType >::data(), and Nektar::Array< OneD, const DataType >::size().

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

◆ CreateStorage() [1/4]

template<typename Dim , typename DataType , typename ExtentListType >

std::shared_ptr< boost::multi_array_ref< DataType, Dim::Value > > Nektar::CreateStorage ( const ExtentListType & extent )

Definition at line 181 of file ArrayPolicies.hpp.

{
    typedef boost::multi_array_ref<DataType, Dim::Value> ArrayType;
    size_t size       = std::accumulate(extent.begin(), extent.end(), 1,
                                        std::multiplies<size_t>());
    DataType *storage = MemoryManager<DataType>::RawAllocate(size);
    return MemoryManager<ArrayType>::AllocateSharedPtrD(
        [=]([[maybe_unused]] boost::multi_array_ref<DataType, Dim::Value>
                *ptr) {
            ArrayDestructionPolicy<DataType>::Destroy(storage, size);
            MemoryManager<DataType>::RawDeallocate(storage, size);
        },
        storage, extent);
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtrD(), Nektar::MemoryManager< DataType >::RawAllocate(), and Nektar::MemoryManager< DataType >::RawDeallocate().

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

◆ CreateStorage() [2/4]

template<typename DataType >

std::shared_ptr< boost::multi_array_ref< DataType, 1 > > Nektar::CreateStorage ( size_t d1 )

Definition at line 198 of file ArrayPolicies.hpp.

{
    std::vector<size_t> extents = {d1};
    return CreateStorage<OneD, DataType>(extents);
}

◆ CreateStorage() [3/4]

template<typename DataType >

std::shared_ptr< boost::multi_array_ref< DataType, 2 > > Nektar::CreateStorage	(	size_t	d1,
		size_t	d2
	)

Definition at line 205 of file ArrayPolicies.hpp.

{
    std::vector<size_t> extents = {d1, d2};
    return CreateStorage<TwoD, DataType>(extents);
}

◆ CreateStorage() [4/4]

template<typename DataType >

std::shared_ptr< boost::multi_array_ref< DataType, 3 > > Nektar::CreateStorage	(	size_t	d1,
		size_t	d2,
		size_t	d3
	)

Definition at line 213 of file ArrayPolicies.hpp.

{
    std::vector<size_t> extents = {d1, d2, d3};
    return CreateStorage<ThreeD, DataType>(extents);
}

◆ createVectorFromPoints() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::createVectorFromPoints	(	const NekPoint< DataType > &	source,
		const NekPoint< DataType > &	dest
	)

Definition at line 995 of file NekVector.cpp.

{
    NekVector<DataType> result(3, 0.0);
    for (unsigned int i = 0; i < 3; ++i)
    {
        result[i] = dest[i] - source[i];
    }
    return result;
}

◆ createVectorFromPoints() [2/3]

template NekVector< NekDouble > Nektar::createVectorFromPoints	(	const NekPoint< NekDouble > &	source,
		const NekPoint< NekDouble > &	dest
	)

◆ createVectorFromPoints() [3/3]

template NekVector< NekSingle > Nektar::createVectorFromPoints	(	const NekPoint< NekSingle > &	source,
		const NekPoint< NekSingle > &	dest
	)

◆ Cross() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::Cross	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1246 of file NekVector.cpp.

{
    ASSERTL1(lhs.GetDimension() == 3 && rhs.GetDimension() == 3,
             "Cross is only valid for 3D vectors.");
 
    DataType first  = lhs.y() * rhs.z() - lhs.z() * rhs.y();
    DataType second = lhs.z() * rhs.x() - lhs.x() * rhs.z();
    DataType third  = lhs.x() * rhs.y() - lhs.y() * rhs.x();
 
    NekVector<DataType> result(first, second, third);
    return result;
}

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().

◆ Cross() [2/3]

template NekVector< NekDouble > Nektar::Cross	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Cross() [3/3]

template NekVector< NekSingle > Nektar::Cross	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ DiagonalBlockFullScalMatrixMultiply() [1/2]

void Nektar::DiagonalBlockFullScalMatrixMultiply	(	NekVector< double > &	result,
		const NekMatrix< NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &	lhs,
		const NekVector< double > &	rhs
	)

Definition at line 247 of file MatrixVectorMultiplication.cpp.

{
    unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
    double *result_ptr             = result.GetRawPtr();
    const double *rhs_ptr          = rhs.GetRawPtr();
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
    lhs.GetBlockSizes(rowSizes, colSizes);
 
    unsigned int curResultRow   = 0;
    unsigned int curWrapperRow  = 0;
    unsigned int rowsInBlock    = 0;
    unsigned int columnsInBlock = 0;
    for (unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
    {
        curResultRow += rowsInBlock;
        curWrapperRow += columnsInBlock;
        if (blockRow == 0)
        {
            rowsInBlock    = rowSizes[blockRow] + 1;
            columnsInBlock = colSizes[blockRow] + 1;
        }
        else
        {
            rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow - 1];
            columnsInBlock = colSizes[blockRow] - colSizes[blockRow - 1];
        }
 
        if (rowsInBlock == 0)
        {
            continue;
        }
        if (columnsInBlock == 0)
        {
            std::fill(result.begin() + curResultRow,
                      result.begin() + curResultRow + rowsInBlock, 0.0);
            continue;
        }
 
        const DNekScalMat *block = lhs.GetBlockPtr(blockRow, blockRow);
        if (!block)
        {
            continue;
        }
 
        double *resultWrapper    = result_ptr + curResultRow;
        const double *rhsWrapper = rhs_ptr + curWrapperRow;
 
        // Multiply
        const unsigned int *size = block->GetSize();
        Blas::Gemv('N', size[0], size[1], block->Scale(), block->GetRawPtr(),
                   size[0], rhsWrapper, 1, 0.0, resultWrapper, 1);
    }
    curResultRow += rowsInBlock;
    if (curResultRow < result.GetRows())
    {
        std::fill(result.begin() + curResultRow, result.end(), 0.0);
    }
}

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Blas::Gemv(), Nektar::NekVector< DataType >::GetRawPtr(), and Nektar::NekVector< DataType >::GetRows().

◆ DiagonalBlockFullScalMatrixMultiply() [2/2]

void Nektar::DiagonalBlockFullScalMatrixMultiply	(	NekVector< NekSingle > &	result,
		const NekMatrix< NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag >, BlockMatrixTag > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Definition at line 313 of file MatrixVectorMultiplication.cpp.

{
    unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
    NekSingle *result_ptr          = result.GetRawPtr();
    const NekSingle *rhs_ptr       = rhs.GetRawPtr();
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
    lhs.GetBlockSizes(rowSizes, colSizes);
 
    unsigned int curResultRow   = 0;
    unsigned int curWrapperRow  = 0;
    unsigned int rowsInBlock    = 0;
    unsigned int columnsInBlock = 0;
    for (unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
    {
        curResultRow += rowsInBlock;
        curWrapperRow += columnsInBlock;
        if (blockRow == 0)
        {
            rowsInBlock    = rowSizes[blockRow] + 1;
            columnsInBlock = colSizes[blockRow] + 1;
        }
        else
        {
            rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow - 1];
            columnsInBlock = colSizes[blockRow] - colSizes[blockRow - 1];
        }
 
        if (rowsInBlock == 0)
        {
            continue;
        }
        if (columnsInBlock == 0)
        {
            std::fill(result.begin() + curResultRow,
                      result.begin() + curResultRow + rowsInBlock, 0.0);
            continue;
        }
 
        const SNekScalMat *block = lhs.GetBlockPtr(blockRow, blockRow);
        if (!block)
        {
            continue;
        }
 
        NekSingle *resultWrapper    = result_ptr + curResultRow;
        const NekSingle *rhsWrapper = rhs_ptr + curWrapperRow;
 
        // Multiply
        const unsigned int *size = block->GetSize();
        Blas::Gemv('N', size[0], size[1], block->Scale(), block->GetRawPtr(),
                   size[0], rhsWrapper, 1, 0.0, resultWrapper, 1);
    }
    curResultRow += rowsInBlock;
    if (curResultRow < result.GetRows())
    {
        std::fill(result.begin() + curResultRow, result.end(), 0.0);
    }
}

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), Blas::Gemv(), Nektar::NekVector< DataType >::GetRawPtr(), and Nektar::NekVector< DataType >::GetRows().

◆ DiagonalBlockMatrixMultiply()

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::DiagonalBlockMatrixMultiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 187 of file MatrixVectorMultiplication.cpp.

{
    unsigned int numberOfBlockRows = lhs.GetNumberOfBlockRows();
    DataType *result_ptr           = result.GetRawPtr();
    const DataType *rhs_ptr        = rhs.GetRawPtr();
 
    Array<OneD, unsigned int> rowSizes;
    Array<OneD, unsigned int> colSizes;
    lhs.GetBlockSizes(rowSizes, colSizes);
 
    unsigned int curResultRow   = 0;
    unsigned int curWrapperRow  = 0;
    unsigned int rowsInBlock    = 0;
    unsigned int columnsInBlock = 0;
    for (unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
    {
        curResultRow += rowsInBlock;
        curWrapperRow += columnsInBlock;
        if (blockRow == 0)
        {
            rowsInBlock    = rowSizes[blockRow] + 1;
            columnsInBlock = colSizes[blockRow] + 1;
        }
        else
        {
            rowsInBlock    = rowSizes[blockRow] - rowSizes[blockRow - 1];
            columnsInBlock = colSizes[blockRow] - colSizes[blockRow - 1];
        }
 
        if (rowsInBlock == 0)
        {
            continue;
        }
        if (columnsInBlock == 0)
        {
            std::fill(result.begin() + curResultRow,
                      result.begin() + curResultRow + rowsInBlock, 0.0);
            continue;
        }
 
        const LhsInnerMatrixType *block = lhs.GetBlockPtr(blockRow, blockRow);
        if (!block)
        {
            continue;
        }
 
        DataType *resultWrapper    = result_ptr + curResultRow;
        const DataType *rhsWrapper = rhs_ptr + curWrapperRow;
        Multiply(resultWrapper, *block, rhsWrapper);
    }
    curResultRow += rowsInBlock;
    if (curResultRow < result.GetRows())
    {
        std::fill(result.begin() + curResultRow, result.end(), 0.0);
    }
}

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

Referenced by Multiply().

◆ distanceBetween()

template<typename DataType >

boost::call_traits< DataType >::value_type Nektar::distanceBetween	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 462 of file NekPoint.hpp.

{
    DataType result = 0.0;
    for (unsigned int i = 0; i < 3; ++i)
    {
        DataType temp = lhs[i] - rhs[i];
        result += temp * temp;
    }
    return sqrt(result);
}

References tinysimd::sqrt().

◆ Divide() [1/8]

template<typename DataType >

NekVector< DataType > Nektar::Divide	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 741 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Divide(result, lhs, rhs);
    return result;
}

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

◆ Divide() [2/8]

template<typename DataType >

NekVector< DataType > Nektar::Divide	(	const NekVector< DataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 749 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Divide(result, lhs, rhs);
    return result;
}

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

◆ Divide() [3/8]

template NekVector< NekDouble > Nektar::Divide	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

◆ Divide() [4/8]

template NekVector< NekSingle > Nektar::Divide	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

Referenced by Divide().

◆ Divide() [5/8]

template void Nektar::Divide	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

◆ Divide() [6/8]

template void Nektar::Divide	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

◆ Divide() [7/8]

template<typename ResultDataType , typename InputDataType >

void Nektar::Divide	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 675 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
 
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] / rhs;
    }
}

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

Referenced by operator/().

◆ Divide() [8/8]

template<typename ResultDataType , typename InputDataType >

void Nektar::Divide	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 689 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
 
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] / rhs;
    }
}

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

◆ DivideEqual() [1/4]

template void Nektar::DivideEqual	(	NekVector< NekDouble > &	result,
		const NekDouble &	rhs
	)

◆ DivideEqual() [2/4]

template void Nektar::DivideEqual	(	NekVector< NekSingle > &	result,
		const NekSingle &	rhs
	)

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

◆ DivideEqual() [3/4]

template<typename ResultDataType >

void Nektar::DivideEqual	(	NekVector< ResultDataType > &	result,
		const NekDouble &	rhs
	)

Definition at line 711 of file NekVector.cpp.

{
    ResultDataType *r_buf = result.GetRawPtr();
 
    const unsigned int resdim = result.GetDimension();
    for (int i = 0; i < resdim; ++i)
    {
        r_buf[i] /= rhs;
    }
}

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

◆ DivideEqual() [4/4]

template<typename ResultDataType >

void Nektar::DivideEqual	(	NekVector< ResultDataType > &	result,
		const NekSingle &	rhs
	)

Definition at line 723 of file NekVector.cpp.

{
    ResultDataType *r_buf = result.GetRawPtr();
 
    const unsigned int resdim = result.GetDimension();
    for (int i = 0; i < resdim; ++i)
    {
        r_buf[i] /= rhs;
    }
}

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

◆ Dot() [1/3]

template<typename DataType >

DataType Nektar::Dot	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1193 of file NekVector.cpp.

{
    ASSERTL1(lhs.GetDimension() == rhs.GetDimension(),
             "Dot, dimension of the two operands must be identical.");
 
    DataType result         = DataType(0);
    const unsigned int ldim = lhs.GetDimension();
    for (unsigned int i = 0; i < ldim; ++i)
    {
        result += lhs[i] * rhs[i];
    }
 
    return result;
}

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

Referenced by Nektar::PulseWaveSystem::BifurcationRiemann(), Nektar::NekVector< DataType >::Dot(), Nektar::PulseWaveSystem::InterfaceRiemann(), and Nektar::PulseWaveSystem::MergingRiemann().

◆ Dot() [2/3]

template NekDouble Nektar::Dot	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Dot() [3/3]

template NekSingle Nektar::Dot	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ EmptyString()

bool Nektar::EmptyString ( const char * s )

inline

Check to see whether the given string s is empty (or null).

Definition at line 50 of file Metric.h.

{
    if (!s)
    {
        return true;
    }
    return std::string(s) == "";
}

Referenced by Nektar::MetricEigenvalue::MetricEigenvalue(), Nektar::MetricExecutionTime::MetricExecutionTime(), Nektar::MetricL2::MetricL2(), Nektar::MetricLInf::MetricLInf(), Nektar::MetricPrecon::MetricPrecon(), and Nektar::MetricPyUnitTest::MetricPyUnitTest().

◆ findPointAlongVector() [1/3]

template<typename DataType >

NekPoint< DataType > Nektar::findPointAlongVector	(	const NekVector< DataType > &	lhs,
		const DataType &	t
	)

Definition at line 1013 of file NekVector.cpp.

{
    NekPoint<DataType> result;
    for (unsigned int i = 0; i < 3; ++i)
    {
        result[i] = lhs[i] * t;
    }
 
    return result;
}

◆ findPointAlongVector() [2/3]

template NekPoint< NekDouble > Nektar::findPointAlongVector	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	t
	)

◆ findPointAlongVector() [3/3]

template NekPoint< NekSingle > Nektar::findPointAlongVector	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	t
	)

◆ FromString() [1/2]

template<typename DataType >

std::vector< DataType > Nektar::FromString ( const std::string & str )

Definition at line 1061 of file NekVector.cpp.

{
    std::vector<DataType> result;
 
    try
    {
        typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
        boost::char_separator<char> sep("(<,>) ");
        tokenizer tokens(str, sep);
        for (tokenizer::iterator strIter = tokens.begin();
             strIter != tokens.end(); ++strIter)
        {
            result.push_back(boost::lexical_cast<DataType>(*strIter));
        }
    }
    catch (boost::bad_lexical_cast &)
    {
    }
 
    return result;
}

◆ FromString() [2/2]

template std::vector< NekDouble > Nektar::FromString ( const std::string & str )

◆ fromString()

template<typename DataType >

bool Nektar::fromString	(	const std::string &	str,
		NekPoint< DataType > &	result
	)

Definition at line 475 of file NekPoint.hpp.

{
    try
    {
        typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
        boost::char_separator<char> sep("(<,>) ");
        tokenizer tokens(str, sep);
        unsigned int i = 0;
        for (tokenizer::iterator iter = tokens.begin(); iter != tokens.end();
             ++iter)
        {
            result[i] = boost::lexical_cast<DataType>(*iter);
            ++i;
        }
 
        return i == 3;
    }
    catch (boost::bad_lexical_cast &)
    {
        return false;
    }
}

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

◆ FullBlockMatrixMultiply()

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::FullBlockMatrixMultiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 118 of file MatrixVectorMultiplication.cpp.

{
    unsigned int numberOfBlockRows    = lhs.GetNumberOfBlockRows();
    unsigned int numberOfBlockColumns = lhs.GetNumberOfBlockColumns();
    DataType *result_ptr              = result.GetRawPtr();
    const DataType *rhs_ptr           = rhs.GetRawPtr();
 
    for (unsigned int i = 0; i < result.GetDimension(); ++i)
    {
        result_ptr[i] = DataType(0);
    }
    Array<OneD, DataType> temp(result.GetDimension());
    DataType *temp_ptr = temp.get();
 
    unsigned int curResultRow = 0;
    for (unsigned int blockRow = 0; blockRow < numberOfBlockRows; ++blockRow)
    {
        unsigned int rowsInBlock = lhs.GetNumberOfRowsInBlockRow(blockRow);
 
        if (blockRow != 0)
        {
            curResultRow += lhs.GetNumberOfRowsInBlockRow(blockRow - 1);
        }
 
        if (rowsInBlock == 0)
        {
            continue;
        }
 
        DataType *resultWrapper = result_ptr + curResultRow;
 
        unsigned int curWrapperRow = 0;
        for (unsigned int blockColumn = 0; blockColumn < numberOfBlockColumns;
             ++blockColumn)
        {
            if (blockColumn != 0)
            {
                curWrapperRow +=
                    lhs.GetNumberOfColumnsInBlockColumn(blockColumn - 1);
            }
 
            const LhsInnerMatrixType *block =
                lhs.GetBlockPtr(blockRow, blockColumn);
            if (!block)
            {
                continue;
            }
 
            unsigned int columnsInBlock =
                lhs.GetNumberOfColumnsInBlockColumn(blockColumn);
            if (columnsInBlock == 0)
            {
                continue;
            }
 
            const DataType *rhsWrapper = rhs_ptr + curWrapperRow;
            Multiply(temp_ptr, *block, rhsWrapper);
            for (unsigned int i = 0; i < rowsInBlock; ++i)
            {
                resultWrapper[i] += temp_ptr[i];
            }
        }
    }
}

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

Referenced by Multiply().

◆ GenerateFullMatrices()

void Nektar::GenerateFullMatrices	(	double	values[],
		double	scale,
		std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > &	m1,
		std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, ScaledMatrixTag > > &	m2,
		std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, BlockMatrixTag > > &	m3
	)

Definition at line 45 of file TestNekMatrixOperations.cpp.

{
    m1 =
        std::make_shared<NekMatrix<NekDouble, StandardMatrixTag>>(4, 4, values);
 
    double inner_values[16];
    std::transform(
        values, values + 16, inner_values,
        std::bind(std::divides<NekDouble>(), std::placeholders::_1, scale));
 
    std::shared_ptr<NekMatrix<NekDouble>> inner(
        new NekMatrix<NekDouble>(4, 4, inner_values));
    m2 = std::make_shared<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>>(
        scale, inner);
 
    double block_1_values[] = {values[0], values[1], values[4], values[5]};
    double block_2_values[] = {values[2], values[3], values[6], values[7]};
    double block_3_values[] = {values[8], values[9], values[12], values[13]};
    double block_4_values[] = {values[10], values[11], values[14], values[15]};
    std::shared_ptr<NekMatrix<NekDouble>> block1(
        new NekMatrix<NekDouble>(2, 2, block_1_values));
    std::shared_ptr<NekMatrix<NekDouble>> block2(
        new NekMatrix<NekDouble>(2, 2, block_2_values));
    std::shared_ptr<NekMatrix<NekDouble>> block3(
        new NekMatrix<NekDouble>(2, 2, block_3_values));
    std::shared_ptr<NekMatrix<NekDouble>> block4(
        new NekMatrix<NekDouble>(2, 2, block_4_values));
 
    m3 = std::make_shared<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>>(
        2, 2, 2, 2);
    m3->SetBlock(0, 0, block1);
    m3->SetBlock(1, 0, block2);
    m3->SetBlock(0, 1, block3);
    m3->SetBlock(1, 1, block4);
}

Referenced by Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE(), and Nektar::MatrixSubtractionTests::BOOST_AUTO_TEST_CASE().

◆ GenerateMatrices()

template<typename NumberType >

void Nektar::GenerateMatrices	(	const NekMatrix< NumberType, StandardMatrixTag > &	m1,
		NumberType	scale,
		unsigned int	blockRows,
		unsigned int	blockColumns,
		std::shared_ptr< NekMatrix< NekMatrix< NumberType, StandardMatrixTag >, ScaledMatrixTag > > &	m2,
		std::shared_ptr< NekMatrix< NekMatrix< NumberType >, BlockMatrixTag > > &	m3
	)

Definition at line 98 of file TestCombinationRunner.h.

{
    NumberType *inner_values = new NumberType[m1.GetStorageSize()];
    std::transform(
        m1.begin(), m1.end(), inner_values,
        std::bind(std::divides<NumberType>(), std::placeholders::_1, scale));
    MatrixStorage s = m1.GetType();
 
    std::shared_ptr<NekMatrix<NumberType, StandardMatrixTag>> inner(
        new NekMatrix<NumberType, StandardMatrixTag>(
            m1.GetRows(), m1.GetColumns(), inner_values, s,
            m1.GetNumberOfSubDiagonals(), m1.GetNumberOfSuperDiagonals()));
    m2 = std::make_shared<
        NekMatrix<NekMatrix<NumberType, StandardMatrixTag>, ScaledMatrixTag>>(
        scale, inner);
 
    unsigned int numberOfRows    = m1.GetRows() / blockRows;
    unsigned int numberOfColumns = m1.GetColumns() / blockColumns;
    m3 = std::make_shared<NekMatrix<NekMatrix<NumberType>, BlockMatrixTag>>(
        blockRows, blockColumns, numberOfRows, numberOfColumns);
 
    for (unsigned int blockRow = 0; blockRow < blockRows; ++blockRow)
    {
        for (unsigned int blockColumn = 0; blockColumn < blockColumns;
             ++blockColumn)
        {
            std::shared_ptr<NekMatrix<NumberType>> block(
                new NekMatrix<NumberType>(numberOfRows, numberOfColumns));
            for (unsigned int i = 0; i < numberOfRows; ++i)
            {
                for (unsigned int j = 0; j < numberOfRows; ++j)
                {
                    (*block)(i, j) = m1(numberOfRows * blockRow + i,
                                        numberOfColumns * blockColumn + j);
                }
            }
 
            m3->SetBlock(blockRow, blockColumn, block);
        }
    }
 
    delete[] inner_values;
}

Referenced by Nektar::StandardMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE(), and Nektar::BandedMatrixMatrixMultiplicationTests::BOOST_AUTO_TEST_CASE().

◆ GenerateUpperTriangularMatrices()

void Nektar::GenerateUpperTriangularMatrices	(	NekDouble	values[],
		NekDouble	scale,
		std::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > &	m1,
		std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, ScaledMatrixTag > > &	m2,
		std::shared_ptr< NekMatrix< NekMatrix< NekDouble >, BlockMatrixTag > > &	m3
	)

Definition at line 85 of file TestNekMatrixOperations.cpp.

{
    m1 = std::make_shared<NekMatrix<NekDouble, StandardMatrixTag>>(
        4, 4, values, eUPPER_TRIANGULAR);
 
    double inner_values[10];
    std::transform(
        values, values + 10, inner_values,
        std::bind(std::divides<NekDouble>(), std::placeholders::_1, scale));
 
    std::shared_ptr<NekMatrix<NekDouble>> inner(
        new NekMatrix<NekDouble>(4, 4, inner_values, eUPPER_TRIANGULAR));
    m2 = std::make_shared<NekMatrix<NekMatrix<NekDouble>, ScaledMatrixTag>>(
        scale, inner);
 
    double block_1_values[] = {values[0], 0.0, values[1], values[2]};
    double block_2_values[] = {values[3], values[4], values[6], values[7]};
    double block_4_values[] = {values[5], 0.0, values[8], values[9]};
    std::shared_ptr<NekMatrix<NekDouble>> block1(
        new NekMatrix<NekDouble>(2, 2, block_1_values));
    std::shared_ptr<NekMatrix<NekDouble>> block2(
        new NekMatrix<NekDouble>(2, 2, block_2_values));
    std::shared_ptr<NekMatrix<NekDouble>> block4(
        new NekMatrix<NekDouble>(2, 2, block_4_values));
 
    m3 = std::make_shared<NekMatrix<NekMatrix<NekDouble>, BlockMatrixTag>>(
        2, 2, 2, 2);
    m3->SetBlock(0, 0, block1);
    m3->SetBlock(0, 1, block2);
    m3->SetBlock(1, 1, block4);
}

References eUPPER_TRIANGULAR.

Referenced by Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE().

◆ GetArtificialDiffusionFactory()

ArtificialDiffusionFactory & Nektar::GetArtificialDiffusionFactory ( )

Declaration of the artificial diffusion factory singleton.

Definition at line 42 of file ArtificialDiffusion.cpp.

{
    static ArtificialDiffusionFactory instance;
    return instance;
}

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

◆ GetBoundaryFactory()

BoundaryFactory & Nektar::GetBoundaryFactory ( )

Definition at line 62 of file PulseWaveBoundary.cpp.

{
    static BoundaryFactory instance;
    return instance;
}

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

◆ GetCellModelFactory()

CellModelFactory & Nektar::GetCellModelFactory ( )

Definition at line 46 of file CellModel.cpp.

{
    static CellModelFactory instance;
    return instance;
}

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

◆ GetCFSBndCondFactory()

CFSBndCondFactory & Nektar::GetCFSBndCondFactory ( )

Declaration of the boundary condition factory singleton.

Definition at line 41 of file CFSBndCond.cpp.

{
    static CFSBndCondFactory instance;
    return instance;
}

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

◆ GetEquationOfStateFactory()

EquationOfStateFactory & Nektar::GetEquationOfStateFactory ( )

Declaration of the equation of state factory singleton.

Definition at line 41 of file EquationOfState.cpp.

{
    static EquationOfStateFactory instance;
    return instance;
}

Referenced by Nektar::CompressibleSolver::CompressibleSolver(), Nektar::DiffusionLDGNS::v_InitObject(), and Nektar::VariableConverter::VariableConverter().

◆ GetExtrapolateFactory()

ExtrapolateFactory & Nektar::GetExtrapolateFactory ( )

Definition at line 48 of file Extrapolate.cpp.

{
    static ExtrapolateFactory instance;
    return instance;
}

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

◆ GetIncBCFactory()

SOLVER_UTILS_EXPORT IncBCFactory & Nektar::GetIncBCFactory ( )

Definition at line 47 of file IncBaseCondition.cpp.

{
    static IncBCFactory instance;
    return instance;
}

Referenced by Nektar::IncBoundaryConditions::Initialize().

◆ GetMemoryPool()

MemPool & Nektar::GetMemoryPool ( )

Definition at line 39 of file ThreadSpecificPool.cpp.

{
    static MemPool instance;
    return instance;
}

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

◆ GetMetricFactory()

MetricFactory & Nektar::GetMetricFactory ( )

Definition at line 42 of file Metric.cpp.

{
    static MetricFactory instance;
    return instance;
}

Referenced by main().

◆ GetPreconCfsFactory()

PreconCfsFactory & Nektar::GetPreconCfsFactory ( )

Declaration of the boundary condition factory singleton.

Definition at line 42 of file PreconCfs.cpp.

{
    static PreconCfsFactory instance;
    return instance;
}

Referenced by Nektar::CFSImplicit::InitialiseNonlinSysSolver().

◆ GetPressureAreaFactory()

PressureAreaFactory & Nektar::GetPressureAreaFactory ( )

Definition at line 54 of file PulseWavePressureArea.cpp.

{
    static PressureAreaFactory instance;
    return instance;
}

Referenced by Nektar::UpwindPulseSolver::RiemannSolverUpwind(), Nektar::PulseWavePropagation::v_InitObject(), and Nektar::PulseWaveSystem::v_InitObject().

◆ GetProtocolFactory()

ProtocolFactory & Nektar::GetProtocolFactory ( )

Definition at line 39 of file Protocol.cpp.

{
    static ProtocolFactory instance;
    return instance;
}

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

◆ GetStimulusFactory()

StimulusFactory & Nektar::GetStimulusFactory ( )

Definition at line 44 of file Stimulus.cpp.

{
    static StimulusFactory instance;
    return instance;
}

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

◆ guessp()

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

g	Array of calculated gamma values.
rhoL	Density left state.
rhoR	Density right state.
uL	x-velocity component left state.
uR	x-velocity component right state.
pL	Pressure component left state.
pR	Pressure component right state.
cL	Sound speed component left state.
cR	Sound speed component right state.

Returns: Computed initial guess for the Newton-Raphson scheme.

Definition at line 67 of file ExactSolverToro.cpp.

{
    const NekDouble quser = 2.0;
    NekDouble cup, ppv, pmin, pmax, qmax;
 
    cup  = 0.25 * (rhoL + rhoR) * (cL + cR);
    ppv  = 0.5 * (pL + pR) + 0.5 * (uL - uR) * cup;
    ppv  = std::max(0.0, ppv);
    pmin = std::min(pL, pR);
    pmax = std::max(pL, pR);
    qmax = pmax / pmin;
 
    if (qmax <= quser && pmin <= ppv && ppv <= pmax)
    {
        // Select PVRS Riemann solver.
        return ppv;
    }
    else if (ppv < pmin)
    {
        // Select two-rarefaction Riemann solver.
        NekDouble pq = pow(pL / pR, g[1]);
        NekDouble um =
            (pq * uL / cL + uR / cR + g[4] * (pq - 1.0)) / (pq / cL + 1.0 / cR);
        NekDouble ptL = 1.0 + g[7] * (uL - um) / cL;
        NekDouble ptR = 1.0 + g[7] * (um - uR) / cR;
        return 0.5 * (pL * pow(ptL, g[3]) + pR * pow(ptR, g[3]));
    }
    else
    {
        // Select two-shock Riemann solver with PVRS as estimate.
        NekDouble geL = sqrt((g[5] / rhoL) / (g[6] * pL + ppv));
        NekDouble geR = sqrt((g[5] / rhoR) / (g[6] * pR + ppv));
        return (geL * pL + geR * pR - (uR - uL)) / (geL + geR);
    }
}

References tinysimd::sqrt().

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

◆ hash_combine() [1/3]

template<typename T , typename... Args>

std::size_t Nektar::hash_combine	(	const T &	v,
		Args...	args
	)

inline

Definition at line 57 of file HashUtils.hpp.

{
    std::size_t seed = 0;
    hash_combine(seed, args...);
    return seed;
}

References hash_combine().

◆ hash_combine() [2/3]

void Nektar::hash_combine ( std::size_t & seed )

inline

Definition at line 44 of file HashUtils.hpp.

45{

46}

Referenced by Nektar::SpatialDomains::GeomFactors::GetHash(), Nektar::MultiRegions::GlobalLinSysKey::GlobalLinSysKey(), hash_combine(), hash_range(), Nektar::PairHash::operator()(), Nektar::FieldUtils::TriFaceHash::operator()(), VertexHash::operator()(), and Nektar::StdRegions::StdMatrixKey::StdMatrixKey().

◆ hash_combine() [3/3]

template<typename T , typename... Args>

void Nektar::hash_combine	(	std::size_t &	seed,
		const T &	v,
		Args...	args
	)

inline

Definition at line 49 of file HashUtils.hpp.

{
    std::hash<T> hasher;
    seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    hash_combine(seed, args...);
}

References hash_combine().

◆ hash_range() [1/2]

template<typename Iter >

std::size_t Nektar::hash_range	(	Iter	first,
		Iter	last
	)

Definition at line 64 of file HashUtils.hpp.

{
    std::size_t seed = 0;
    for (; first != last; ++first)
    {
        hash_combine(seed, *first);
    }
    return seed;
}

References hash_combine().

Referenced by Nektar::MultiRegions::AssemblyMapCG::AssemblyMapCG(), Nektar::MultiRegions::AssemblyMapDG::AssemblyMapDG(), Nektar::StdRegions::VarCoeffEntry::ComputeHash(), Nektar::CoupledAssemblyMap::CoupledAssemblyMap(), Nektar::SpatialDomains::GeomFactors::GetHash(), Nektar::MultiRegions::GlobalLinSysKey::GlobalLinSysKey(), hash_range(), Nektar::SpatialDomains::GeometryHash::operator()(), and Nektar::StdRegions::StdMatrixKey::StdMatrixKey().

◆ hash_range() [2/2]

template<typename Iter >

void Nektar::hash_range	(	std::size_t &	seed,
		Iter	first,
		Iter	last
	)

Definition at line 75 of file HashUtils.hpp.

{
    hash_combine(seed, hash_range(first, last));
}

References hash_combine(), and hash_range().

◆ InfinityNorm() [1/3]

template<typename DataType >

DataType Nektar::InfinityNorm ( const NekVector< DataType > & v )

Definition at line 1125 of file NekVector.cpp.

{
    DataType result         = fabs(v[0]);
    const unsigned int vdim = v.GetDimension();
    for (unsigned int i = 0; i < vdim; ++i)
    {
        result = std::max(DataType(fabs(v[i])), result);
    }
    return result;
}

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

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

◆ InfinityNorm() [2/3]

template NekDouble Nektar::InfinityNorm ( const NekVector< NekDouble > & v )

◆ InfinityNorm() [3/3]

template NekSingle Nektar::InfinityNorm ( const NekVector< NekSingle > & v )

◆ InvertInPlace() [1/2]

void Nektar::InvertInPlace ( NekDouble & v )

Definition at line 1229 of file NekVector.cpp.

{
    v = 1.0 / v;
}

◆ InvertInPlace() [2/2]

void Nektar::InvertInPlace ( NekSingle & v )

Definition at line 1240 of file NekVector.cpp.

{
    v = 1.0 / v;
}

◆ IsEqual()

template<typename T >

bool Nektar::IsEqual	(	const T &	lhs,
		const T &	rhs
	)

inline

Definition at line 849 of file BasicUtils/SharedArray.hpp.

{
    return IsEqualImpl(lhs, rhs, std::is_floating_point<T>());
}

References IsEqualImpl().

Referenced by operator==().

◆ IsEqualImpl() [1/2]

template<typename T >

bool Nektar::IsEqualImpl	(	const T &	lhs,
		const T &	rhs,
		std::false_type
	)

inline

Definition at line 837 of file BasicUtils/SharedArray.hpp.

{
    return lhs == rhs;
}

Referenced by IsEqual().

◆ IsEqualImpl() [2/2]

template<typename T >

bool Nektar::IsEqualImpl	(	const T &	lhs,
		const T &	rhs,
		std::true_type
	)

inline

Definition at line 844 of file BasicUtils/SharedArray.hpp.

{
    return LibUtilities::IsRealEqual(lhs, rhs);
}

References Nektar::LibUtilities::IsRealEqual().

◆ L1Norm() [1/3]

template<typename DataType >

DataType Nektar::L1Norm ( const NekVector< DataType > & v )

Todo:: Do the Norms with Blas where applicable.

Definition at line 1089 of file NekVector.cpp.

{
    typedef NekVector<DataType> VectorType;
 
    DataType result(0);
    for (typename VectorType::const_iterator iter = v.begin(); iter != v.end();
         ++iter)
    {
        result += fabs(*iter);
    }
 
    return result;
}

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

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

◆ L1Norm() [2/3]

template NekDouble Nektar::L1Norm ( const NekVector< NekDouble > & v )

◆ L1Norm() [3/3]

template NekSingle Nektar::L1Norm ( const NekVector< NekSingle > & v )

◆ L2Norm() [1/3]

template<typename DataType >

DataType Nektar::L2Norm ( const NekVector< DataType > & v )

Definition at line 1107 of file NekVector.cpp.

{
    typedef NekVector<DataType> VectorType;
 
    DataType result(0);
    for (typename VectorType::const_iterator iter = v.begin(); iter != v.end();
         ++iter)
    {
        DataType w = fabs(*iter);
        result += w * w;
    }
    return sqrt(result);
}

References Nektar::NekVector< DataType >::begin(), Nektar::NekVector< DataType >::end(), tinysimd::sqrt(), and Nektar::UnitTests::w().

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

◆ L2Norm() [2/3]

template NekDouble Nektar::L2Norm ( const NekVector< NekDouble > & v )

◆ L2Norm() [3/3]

template NekSingle Nektar::L2Norm ( const NekVector< NekSingle > & v )

◆ Magnitude() [1/3]

template<typename DataType >

DataType Nektar::Magnitude ( const NekVector< DataType > & v )

Definition at line 1174 of file NekVector.cpp.

{
    DataType result = DataType(0);
 
    const unsigned int vdim = v.GetDimension();
    for (unsigned int i = 0; i < vdim; ++i)
    {
        result += v[i] * v[i];
    }
    return sqrt(result);
}

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

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

◆ Magnitude() [2/3]

template NekDouble Nektar::Magnitude ( const NekVector< NekDouble > & v )

◆ Magnitude() [3/3]

template NekSingle Nektar::Magnitude ( const NekVector< NekSingle > & v )

◆ MappingIdealToRef()

DNekMat Nektar::MappingIdealToRef ( SpatialDomains::GeometrySharedPtr geom )

inline

Definition at line 75 of file LinearElasticSystem.cpp.

{
    int n = geom->GetNumVerts(), i, j;
 
    DNekMat map(n, n, 1.0, eFULL);
    DNekMat mapref(n, n, 1.0, eFULL);
 
    // Extract coordinate information.
    for (i = 0; i < n; ++i)
    {
        for (j = 0; j < n - 1; ++j)
        {
            map(j, i) = (*geom->GetVertex(i))[j];
        }
    }
 
    // Set up reference triangle or tetrahedron mapping.
    if (n == 3)
    {
        mapref(0, 0) = -1.0;
        mapref(1, 0) = -1.0;
        mapref(0, 1) = 1.0;
        mapref(1, 1) = -1.0;
        mapref(0, 2) = -1.0;
        mapref(1, 2) = 1.0;
    }
    else if (n == 4)
    {
        mapref(0, 0) = -1.0;
        mapref(1, 0) = -1.0;
        mapref(2, 0) = -1.0;
        mapref(0, 1) = 1.0;
        mapref(1, 1) = -1.0;
        mapref(2, 1) = -1.0;
        mapref(0, 2) = -1.0;
        mapref(1, 2) = 1.0;
        mapref(2, 2) = -1.0;
        mapref(0, 3) = -1.0;
        mapref(1, 3) = -1.0;
        mapref(2, 3) = 1.0;
    }
 
    map.Invert();
 
    DNekMat newmap = mapref * map;
    DNekMat mapred(n - 1, n - 1, 1.0, eFULL);
 
    for (i = 0; i < n - 1; ++i)
    {
        for (j = 0; j < n - 1; ++j)
        {
            mapred(i, j) = newmap(i, j);
        }
    }
 
    return mapred;
}

References eFULL.

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

◆ Multiply() [1/36]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat const NekSingle NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 103 of file MatrixOperations.cpp.

{
    return Multiply(rhs, lhs);
}

References Multiply().

◆ Multiply() [2/36]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 103 of file MatrixOperations.cpp.

{
    return Multiply(rhs, lhs);
}

References Multiply().

◆ Multiply() [3/36]

template<typename DataType >

NekVector< DataType > Nektar::Multiply	(	const DataType &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 969 of file NekVector.cpp.

{
    return Multiply(rhs, lhs);
}

References Multiply().

◆ Multiply() [4/36]

template NekVector< NekDouble > Nektar::Multiply	(	const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Multiply() [5/36]

template<typename DataType , typename LhsDataType , typename LhsMatrixType >

SNekMat const NekSingle &NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 67 of file MatrixOperations.cpp.

{
    typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType
        ResultDataType;
    NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(),
                                                        lhs.GetColumns());
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

◆ Multiply() [6/36]

template<typename DataType , typename LhsDataType , typename LhsMatrixType >

NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 67 of file MatrixOperations.cpp.

{
    typedef typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType
        ResultDataType;
    NekMatrix<ResultDataType, StandardMatrixTag> result(lhs.GetRows(),
                                                        lhs.GetColumns());
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

◆ Multiply() [7/36]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Nektar::Multiply	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 261 of file MatrixOperations.hpp.

{
    typedef typename std::remove_const<
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType>::type
        NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    rhs.GetColumns());
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

◆ Multiply() [8/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector< DataType > Nektar::Multiply	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 615 of file MatrixVectorMultiplication.cpp.

{
    NekVector<DataType> result(lhs.GetRows(), DataType(0));
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

◆ Multiply() [9/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector< NekSingle > const NekVector< NekSingle > &NekVector< DataType > Nektar::Multiply	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 615 of file MatrixVectorMultiplication.cpp.

{
    NekVector<DataType> result(lhs.GetRows(), DataType(0));
    Multiply(result, lhs, rhs);
    return result;
}

References Multiply().

◆ Multiply() [10/36]

template NekVector< NekSingle > Nektar::Multiply	(	const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Referenced by Multiply().

◆ Multiply() [11/36]

template<typename DataType >

NekVector< DataType > Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 883 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Multiply(result, lhs, rhs);
    return result;
}

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

◆ Multiply() [12/36]

template<typename DataType >

NekVector< DataType > Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 892 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Multiply(result, lhs, rhs);
    return result;
}

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

◆ Multiply() [13/36]

template<typename DataType , typename InputDataType >

NekVector< DataType > Nektar::Multiply	(	const NekVector< DataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 805 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Multiply(result, lhs, rhs);
    return result;
}

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

◆ Multiply() [14/36]

template NekVector< NekDouble > Nektar::Multiply	(	const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

◆ Multiply() [15/36]

template NekVector< NekDouble > Nektar::Multiply	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Multiply() [16/36]

template NekVector< NekSingle > Nektar::Multiply	(	const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

◆ Multiply() [17/36]

template NekVector< NekSingle > Nektar::Multiply	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ Multiply() [18/36]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::Multiply	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 539 of file MatrixVectorMultiplication.cpp.

{
    switch (lhs.GetType())
    {
        case eFULL:
            NekMultiplyFullMatrix(result, lhs, rhs);
            break;
        case eDIAGONAL:
            NekMultiplyDiagonalMatrix(result, lhs, rhs);
            break;
        case eUPPER_TRIANGULAR:
            NekMultiplyUpperTriangularMatrix(result, lhs, rhs);
            break;
        case eLOWER_TRIANGULAR:
            NekMultiplyLowerTriangularMatrix(result, lhs, rhs);
            break;
        case eSYMMETRIC:
            NekMultiplySymmetricMatrix(result, lhs, rhs);
            break;
        case eBANDED:
            NekMultiplyBandedMatrix(result, lhs, rhs);
            break;
        case eSYMMETRIC_BANDED:
        case eUPPER_TRIANGULAR_BANDED:
        case eLOWER_TRIANGULAR_BANDED:
        default:
            NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
    }
}

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

◆ Multiply() [19/36]

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 177 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetColumns() == rhs.GetRows(),
             std::string("A left side matrix with column count ") +
                 std::to_string(lhs.GetColumns()) +
                 std::string(" and a right side matrix with row count ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be multiplied."));
 
    result.SetSize(lhs.GetRows(), rhs.GetColumns());
    if (lhs.GetType() == eFULL && rhs.GetType() == eFULL)
    {
        NekMultiplyFullMatrixFullMatrix(result, lhs, rhs);
    }
    else
    {
        NekMultiplyDefaultImpl(result, lhs, rhs);
    }
}

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

◆ Multiply() [20/36]

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 41 of file MatrixOperations.cpp.

{
    // TODO - optimize for the different matrix types.
    int n = lhs.GetRows();
    int m = lhs.GetColumns();
    for (unsigned int i = 0; i < n; ++i)
    {
        for (unsigned int j = 0; j < m; ++j)
        {
            result(i, j) = lhs(i, j) * rhs;
        }
    }
}

Referenced by Nektar::PulseWaveSystem::BifurcationRiemann(), DiagonalBlockMatrixMultiply(), FullBlockMatrixMultiply(), Nektar::PulseWaveSystem::InterfaceRiemann(), Nektar::PulseWaveSystem::MergingRiemann(), Multiply(), operator*(), and Nektar::MultiRegions::GlobalLinSysStaticCond::v_Solve().

◆ Multiply() [21/36]

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >

const NekSingle &void Nektar::Multiply	(	NekMatrix< ResultDataType, StandardMatrixTag > &	result,
		const ResultDataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 85 of file MatrixOperations.cpp.

{
    Multiply(result, rhs, lhs);
}

References Multiply().

◆ Multiply() [22/36]

template<typename RhsDataType , typename RhsMatrixType , typename ResultDataType >

void Nektar::Multiply	(	NekMatrix< ResultDataType, StandardMatrixTag > &	result,
		const ResultDataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 85 of file MatrixOperations.cpp.

{
    Multiply(result, rhs, lhs);
}

References Multiply().

◆ Multiply() [23/36]

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 571 of file MatrixVectorMultiplication.cpp.

{
 
    ASSERTL1(lhs.GetColumns() == rhs.GetRows(),
             std::string("A left side matrix with column count ") +
                 std::to_string(lhs.GetColumns()) +
                 std::string(" and a right side vector with row count ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be multiplied."));
    Multiply(result.GetRawPtr(), lhs, rhs.GetRawPtr());
}

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

◆ Multiply() [24/36]

template<typename DataType , typename LhsInnerMatrixType >

void Nektar::Multiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 593 of file MatrixVectorMultiplication.cpp.

{
    if (lhs.GetStorageType() == eDIAGONAL)
    {
        DiagonalBlockMatrixMultiply(result, lhs, rhs);
    }
    else
    {
        FullBlockMatrixMultiply(result, lhs, rhs);
    }
}

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

◆ Multiply() [25/36]

template<typename DataType , typename LhsInnerMatrixType >

NekVector< NekSingle > const NekVector< NekSingle > &void Nektar::Multiply	(	NekVector< DataType > &	result,
		const NekMatrix< LhsInnerMatrixType, BlockMatrixTag > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 593 of file MatrixVectorMultiplication.cpp.

{
    if (lhs.GetStorageType() == eDIAGONAL)
    {
        DiagonalBlockMatrixMultiply(result, lhs, rhs);
    }
    else
    {
        FullBlockMatrixMultiply(result, lhs, rhs);
    }
}

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

◆ Multiply() [26/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Multiply() [27/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekDouble &	rhs
	)

◆ Multiply() [28/36]

template void Nektar::Multiply	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Multiply() [29/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ Multiply() [30/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekSingle &	rhs
	)

◆ Multiply() [31/36]

template void Nektar::Multiply	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ Multiply() [32/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekDouble &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 907 of file NekVector.cpp.

{
    Multiply(result, rhs, lhs);
}

References Multiply().

◆ Multiply() [33/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekSingle &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 930 of file NekVector.cpp.

{
    Multiply(result, rhs, lhs);
}

References Multiply().

◆ Multiply() [34/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 820 of file NekVector.cpp.

{
    ResultDataType *r_buf        = result.GetRawPtr();
    const InputDataType *lhs_buf = lhs.GetRawPtr();
 
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] * rhs;
    }
}

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

◆ Multiply() [35/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekSingle &	rhs
	)

Definition at line 834 of file NekVector.cpp.

{
    ResultDataType *r_buf        = result.GetRawPtr();
    const InputDataType *lhs_buf = lhs.GetRawPtr();
 
    const unsigned int ldim = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] * rhs;
    }
}

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

◆ Multiply() [36/36]

template<typename ResultDataType , typename InputDataType >

void Nektar::Multiply	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 763 of file NekVector.cpp.

{
    ResultDataType *result_buf   = result.GetRawPtr();
    const InputDataType *rhs_buf = rhs.GetRawPtr();
    const InputDataType *lhs_buf = lhs.GetRawPtr();
    const unsigned int resdim    = result.GetDimension();
    for (int i = 0; i < resdim; ++i)
    {
        result_buf[i] = lhs_buf[i] * rhs_buf[i];
    }
}

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

◆ MultiplyEqual() [1/11]

template<typename DataType , typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename std::enable_if< !std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, DataType >::value\|\|!CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > >::value >::type *	t = `0`
	)

Definition at line 219 of file MatrixOperations.hpp.

{
    ASSERTL1(result.GetColumns() == rhs.GetRows(),
             std::string("A left side matrix with column count ") +
                 std::to_string(result.GetColumns()) +
                 std::string(" and a right side matrix with row count ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be multiplied."));
    NekMatrix<DataType, StandardMatrixTag> temp(result.GetRows(),
                                                result.GetColumns());
 
    for (unsigned int i = 0; i < result.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < result.GetColumns(); ++j)
        {
            DataType t = DataType(0);
 
            // Set the result(i,j) element.
            for (unsigned int k = 0; k < result.GetColumns(); ++k)
            {
                t += result(i, k) * rhs(k, j);
            }
            temp(i, j) = t;
        }
    }
 
    result = temp;
}

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

◆ MultiplyEqual() [2/11]

template<typename LhsDataType >

const NekSingle void Nektar::MultiplyEqual	(	NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		typename boost::call_traits< LhsDataType >::const_reference	rhs
	)

Definition at line 117 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, StandardMatrixTag>::iterator iterator;
    for (iterator iter = lhs.begin(); iter != lhs.end(); ++iter)
    {
        *iter *= rhs;
    }
}

◆ MultiplyEqual() [3/11]

template<typename LhsDataType >

void Nektar::MultiplyEqual	(	NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		typename boost::call_traits< LhsDataType >::const_reference	rhs
	)

Definition at line 117 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, StandardMatrixTag>::iterator iterator;
    for (iterator iter = lhs.begin(); iter != lhs.end(); ++iter)
    {
        *iter *= rhs;
    }
}

◆ MultiplyEqual() [4/11]

template<typename RhsInnerType , typename RhsMatrixType >

void Nektar::MultiplyEqual	(	NekMatrix< RhsInnerType, StandardMatrixTag > &	result,
		const NekMatrix< RhsInnerType, RhsMatrixType > &	rhs,
		typename std::enable_if< std::is_same< RawType_t< typename NekMatrix< RhsInnerType, RhsMatrixType >::NumberType >, RhsInnerType >::value &&CanGetRawPtr< NekMatrix< RhsInnerType, RhsMatrixType > >::value >::type *	t = `0`
	)

Definition at line 182 of file MatrixOperations.hpp.

{
    ASSERTL0(result.GetType() == eFULL && rhs.GetType() == eFULL,
             "Only full matrices supported.");
    unsigned int M = result.GetRows();
    unsigned int N = rhs.GetColumns();
    unsigned int K = result.GetColumns();
 
    unsigned int LDA = M;
    if (result.GetTransposeFlag() == 'T')
    {
        LDA = K;
    }
 
    unsigned int LDB = K;
    if (rhs.GetTransposeFlag() == 'T')
    {
        LDB = N;
    }
    RhsInnerType scale             = rhs.Scale();
    Array<OneD, RhsInnerType> &buf = result.GetTempSpace();
    Blas::Gemm(result.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
               scale, result.GetRawPtr(), LDA, rhs.GetRawPtr(), LDB, 0.0,
               buf.data(), result.GetRows());
    result.SetSize(result.GetRows(), rhs.GetColumns());
    result.SwapTempAndDataBuffers();
}

References ASSERTL0, eFULL, and Blas::Gemm().

◆ MultiplyEqual() [5/11]

template void Nektar::MultiplyEqual	(	NekVector< NekDouble > &	result,
		const NekDouble &	rhs
	)

◆ MultiplyEqual() [6/11]

template void Nektar::MultiplyEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

◆ MultiplyEqual() [7/11]

template void Nektar::MultiplyEqual	(	NekVector< NekSingle > &	result,
		const NekSingle &	rhs
	)

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

◆ MultiplyEqual() [8/11]

template void Nektar::MultiplyEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

◆ MultiplyEqual() [9/11]

template<typename ResultDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekDouble &	rhs
	)

Definition at line 856 of file NekVector.cpp.

{
    ResultDataType *r_buf   = result.GetRawPtr();
    const unsigned int rdim = result.GetDimension();
    for (unsigned int i = 0; i < rdim; ++i)
    {
        r_buf[i] *= rhs;
    }
}

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

◆ MultiplyEqual() [10/11]

template<typename ResultDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekSingle &	rhs
	)

Definition at line 867 of file NekVector.cpp.

{
    ResultDataType *r_buf   = result.GetRawPtr();
    const unsigned int rdim = result.GetDimension();
    for (unsigned int i = 0; i < rdim; ++i)
    {
        r_buf[i] *= rhs;
    }
}

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

◆ MultiplyEqual() [11/11]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyEqual	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 786 of file NekVector.cpp.

{
    ResultDataType *result_buf   = result.GetRawPtr();
    const InputDataType *rhs_buf = rhs.GetRawPtr();
    const unsigned int resdim    = result.GetDimension();
    for (int i = 0; i < resdim; ++i)
    {
        result_buf[i] *= rhs_buf[i];
    }
}

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

◆ MultiplyInvertedLhs() [1/4]

template void Nektar::MultiplyInvertedLhs	(	NekVector< NekDouble > &	result,
		const NekDouble &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ MultiplyInvertedLhs() [2/4]

template void Nektar::MultiplyInvertedLhs	(	NekVector< NekSingle > &	result,
		const NekSingle &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ MultiplyInvertedLhs() [3/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyInvertedLhs	(	NekVector< ResultDataType > &	result,
		const NekDouble &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 914 of file NekVector.cpp.

{
    ResultDataType *r_buf        = result.GetRawPtr();
    const InputDataType *rhs_buf = rhs.GetRawPtr();
    NekDouble inverse            = 1.0 / lhs;
 
    const unsigned int rdim = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] = inverse * rhs_buf[i];
    }
}

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

◆ MultiplyInvertedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::MultiplyInvertedLhs	(	NekVector< ResultDataType > &	result,
		const NekSingle &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 937 of file NekVector.cpp.

{
    ResultDataType *r_buf        = result.GetRawPtr();
    const InputDataType *rhs_buf = rhs.GetRawPtr();
    NekSingle inverse            = 1.0 / lhs;
 
    const unsigned int rdim = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] = inverse * rhs_buf[i];
    }
}

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

◆ Negate() [1/3]

template<typename DataType >

NekVector< DataType > Nektar::Negate ( const NekVector< DataType > & v )

Definition at line 1143 of file NekVector.cpp.

{
    NekVector<DataType> temp(v);
    const unsigned int tdim = temp.GetDimension();
    for (unsigned int i = 0; i < tdim; ++i)
    {
        temp(i) = -temp(i);
    }
    return temp;
}

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

◆ Negate() [2/3]

template NekVector< NekDouble > Nektar::Negate ( const NekVector< NekDouble > & v )

◆ Negate() [3/3]

template NekVector< NekSingle > Nektar::Negate ( const NekVector< NekSingle > & v )

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

◆ negate()

template<typename DataType >

void Nektar::negate ( NekPoint< DataType > & rhs )

Definition at line 370 of file NekPoint.hpp.

{
    rhs.negate();
}

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

◆ NegateInPlace() [1/11]

void Nektar::NegateInPlace ( NekDouble & v )

Definition at line 1225 of file NekVector.cpp.

{
    v = -v;
}

◆ NegateInPlace() [2/11]

template<typename DataType >

void Nektar::NegateInPlace ( NekMatrix< DataType, ScaledMatrixTag > & v )

Definition at line 238 of file ScaledMatrix.cpp.

{
    v.SetScale(-1.0 * v.Scale());
}

◆ NegateInPlace() [3/11]

template<typename DataType >

void Nektar::NegateInPlace ( NekMatrix< DataType, StandardMatrixTag > & m )

Definition at line 897 of file StandardMatrix.cpp.

{
    for (unsigned int i = 0; i < m.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < m.GetColumns(); ++j)
        {
            m(i, j) *= -1.0;
        }
    }
}

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

◆ NegateInPlace() [4/11]

template void Nektar::NegateInPlace ( NekMatrix< double, StandardMatrixTag > & v )

◆ NegateInPlace() [5/11]

template void Nektar::NegateInPlace ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > & v )

◆ NegateInPlace() [6/11]

template void Nektar::NegateInPlace ( NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > & v )

◆ NegateInPlace() [7/11]

template void Nektar::NegateInPlace ( NekMatrix< NekSingle, StandardMatrixTag > & v )

◆ NegateInPlace() [8/11]

void Nektar::NegateInPlace ( NekSingle & v )

Definition at line 1236 of file NekVector.cpp.

{
    v = -v;
}

◆ NegateInPlace() [9/11]

template<typename DataType >

void Nektar::NegateInPlace ( NekVector< DataType > & v )

Definition at line 1160 of file NekVector.cpp.

{
    DataType *data          = v.GetRawPtr();
    const unsigned int vdim = v.GetDimension();
    for (unsigned int i = 0; i < vdim; ++i)
    {
        data[i] = -data[i];
    }
}

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

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

◆ NegateInPlace() [10/11]

template void Nektar::NegateInPlace ( NekVector< NekDouble > & v )

◆ NegateInPlace() [11/11]

template void Nektar::NegateInPlace ( NekVector< NekSingle > & v )

◆ NekMultiplyBandedMatrix() [1/2]

template<typename DataType , typename LhsDataType >

void Nektar::NekMultiplyBandedMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, BlockMatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< !CanGetRawPtr< NekMatrix< LhsDataType, BlockMatrixTag > >::value >::type *	p = `nullptr`
	)

Definition at line 105 of file MatrixVectorMultiplication.cpp.

{
    NEKERROR(ErrorUtil::efatal,
             "Banded block matrix multiplication not yet implemented");
}

References Nektar::ErrorUtil::efatal, and NEKERROR.

◆ NekMultiplyBandedMatrix() [2/2]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyBandedMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, MatrixType > >::value >::type *	p = `nullptr`
	)

Definition at line 82 of file MatrixVectorMultiplication.cpp.

{
    int m             = lhs.GetRows();
    int n             = lhs.GetColumns();
    int kl            = lhs.GetNumberOfSubDiagonals();
    int ku            = lhs.GetNumberOfSuperDiagonals();
    DataType alpha    = lhs.Scale();
    const DataType *a = lhs.GetRawPtr();
    int lda           = kl + ku + 1;
    const DataType *x = rhs;
    int incx          = 1;
    DataType beta     = 0.0;
    DataType *y       = result;
    int incy          = 1;
    Blas::Gbmv('N', m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy);
}

References Nektar::LibUtilities::beta, and Blas::Gbmv().

Referenced by Multiply().

◆ NekMultiplyDefaultImpl()

template<typename ResultType , typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

SNekMat const NekSingle &void Nektar::NekMultiplyDefaultImpl	(	NekMatrix< ResultType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 138 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetColumns() == rhs.GetRows(),
             std::string("A left side matrix with column count ") +
                 std::to_string(lhs.GetColumns()) +
                 std::string(" and a right side matrix with row count ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be multiplied."));
 
    for (unsigned int i = 0; i < result.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < result.GetColumns(); ++j)
        {
            ResultType t = ResultType(0);
 
            // Set the result(i,j) element.
            for (unsigned int k = 0; k < lhs.GetColumns(); ++k)
            {
                t += lhs(i, k) * rhs(k, j);
            }
            result(i, j) = t;
        }
    }
}

References ASSERTL1.

Referenced by Multiply(), and NekMultiplyFullMatrixFullMatrix().

◆ NekMultiplyDiagonalMatrix() [1/2]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyDiagonalMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 60 of file MatrixVectorMultiplication.cpp.

{
    int n = lhs.GetRows();
    for (unsigned int i = 0; i < n; ++i)
    {
        result[i] = lhs(i, i) * rhs[i];
    }
}

Referenced by Multiply().

◆ NekMultiplyDiagonalMatrix() [2/2]

template<typename DataType , typename LhsDataType >

void Nektar::NekMultiplyDiagonalMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 72 of file MatrixVectorMultiplication.cpp.

{
    int n                   = lhs.GetRows();
    const DataType *mat_ptr = lhs.GetRawPtr();
    Vmath::Vmul(n, mat_ptr, 1, rhs, 1, result, 1);
}

References Vmath::Vmul().

◆ NekMultiplyFullMatrix() [1/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplyFullMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< !CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = `nullptr`
	)

Definition at line 528 of file MatrixVectorMultiplication.cpp.

{
    NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
}

References NekMultiplyUnspecializedMatrixType().

◆ NekMultiplyFullMatrix() [2/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplyFullMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = `nullptr`
	)

Definition at line 504 of file MatrixVectorMultiplication.cpp.

{
    const unsigned int *size = lhs.GetSize();
 
    char t = lhs.GetTransposeFlag();
 
    DataType alpha    = lhs.Scale();
    const DataType *a = lhs.GetRawPtr();
    int lda           = size[0];
    const DataType *x = rhs;
    int incx          = 1;
    DataType beta     = 0.0;
    DataType *y       = result;
    int incy          = 1;
 
    Blas::Gemv(t, size[0], size[1], alpha, a, lda, x, incx, beta, y, incy);
}

References Nektar::LibUtilities::beta, and Blas::Gemv().

Referenced by Multiply().

◆ NekMultiplyFullMatrixFullMatrix() [1/2]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

void Nektar::NekMultiplyFullMatrixFullMatrix	(	NekMatrix< LhsDataType, StandardMatrixTag > &	result,
		const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< LhsDataType, LhsMatrixType > >::value &&CanGetRawPtr< NekMatrix< RhsDataType, RhsMatrixType > >::value >::type *	p = `nullptr`
	)

Definition at line 142 of file MatrixOperations.hpp.

{
    ASSERTL1(lhs.GetType() == eFULL && rhs.GetType() == eFULL,
             "Only full matrices are supported.");
 
    unsigned int M = lhs.GetRows();
    unsigned int N = rhs.GetColumns();
    unsigned int K = lhs.GetColumns();
 
    unsigned int LDA = M;
    if (lhs.GetTransposeFlag() == 'T')
    {
        LDA = K;
    }
 
    unsigned int LDB = K;
    if (rhs.GetTransposeFlag() == 'T')
    {
        LDB = N;
    }
 
    Blas::Gemm(lhs.GetTransposeFlag(), rhs.GetTransposeFlag(), M, N, K,
               lhs.Scale() * rhs.Scale(), lhs.GetRawPtr(), LDA, rhs.GetRawPtr(),
               LDB, 0.0, result.GetRawPtr(), result.GetRows());
}

References ASSERTL1, eFULL, and Blas::Gemm().

◆ NekMultiplyFullMatrixFullMatrix() [2/2]

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 167 of file MatrixOperations.cpp.

{
    NekMultiplyDefaultImpl(result, lhs, rhs);
}

References NekMultiplyDefaultImpl().

Referenced by Multiply().

◆ NekMultiplyLowerTriangularMatrix() [1/3]

template<typename DataType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< DataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 380 of file MatrixVectorMultiplication.cpp.

{
    int vectorSize = lhs.GetColumns();
    std::copy(rhs, rhs + vectorSize, result);
    int n             = lhs.GetRows();
    const DataType *a = lhs.GetRawPtr();
    DataType *x       = result;
    int incx          = 1;
 
    Blas::Tpmv('L', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
}

References CellMLToNektar.pycml::copy(), Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetRawPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetTransposeFlag(), and Blas::Tpmv().

Referenced by Multiply(), and NekMultiplyLowerTriangularMatrix().

◆ NekMultiplyLowerTriangularMatrix() [2/3]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 410 of file MatrixVectorMultiplication.cpp.

{
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        DataType accum = DataType(0);
        for (unsigned int j = 0; j <= i; ++j)
        {
            accum += lhs(i, j) * rhs[j];
        }
        result[i] = accum;
    }
}

◆ NekMultiplyLowerTriangularMatrix() [3/3]

template<typename DataType >

void Nektar::NekMultiplyLowerTriangularMatrix	(	DataType *	result,
		const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 395 of file MatrixVectorMultiplication.cpp.

{
    NekMultiplyLowerTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
 
    for (unsigned int i = 0; i < lhs.GetColumns(); ++i)
    {
        result[i] *= lhs.Scale();
    }
}

References NekMultiplyLowerTriangularMatrix().

◆ NekMultiplySymmetricMatrix() [1/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplySymmetricMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< !CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = `nullptr`
	)

Definition at line 493 of file MatrixVectorMultiplication.cpp.

{
    NekMultiplyUnspecializedMatrixType(result, lhs, rhs);
}

References NekMultiplyUnspecializedMatrixType().

◆ NekMultiplySymmetricMatrix() [2/2]

template<typename DataType , typename InnerMatrixType , typename MatrixTag >

void Nektar::NekMultiplySymmetricMatrix	(	DataType *	result,
		const NekMatrix< InnerMatrixType, MatrixTag > &	lhs,
		const DataType *	rhs,
		typename std::enable_if< CanGetRawPtr< NekMatrix< InnerMatrixType, MatrixTag > >::value >::type *	p = `nullptr`
	)

Definition at line 472 of file MatrixVectorMultiplication.cpp.

{
    const unsigned int *size = lhs.GetSize();
 
    DataType alpha    = lhs.Scale();
    const DataType *a = lhs.GetRawPtr();
    const DataType *x = rhs;
    int incx          = 1;
    DataType beta     = 0.0;
    DataType *y       = result;
    int incy          = 1;
 
    Blas::Spmv('U', size[0], alpha, a, x, incx, beta, y, incy);
}

References Nektar::LibUtilities::beta, and Blas::Spmv().

Referenced by Multiply().

◆ NekMultiplyUnspecializedMatrixType()

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyUnspecializedMatrixType	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 44 of file MatrixVectorMultiplication.cpp.

{
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        DataType accum = DataType(0);
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            accum += lhs(i, j) * rhs[j];
        }
        result[i] = accum;
    }
}

Referenced by Multiply(), NekMultiplyFullMatrix(), and NekMultiplySymmetricMatrix().

◆ NekMultiplyUpperTriangularMatrix() [1/3]

template<typename DataType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< DataType, StandardMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 426 of file MatrixVectorMultiplication.cpp.

{
    int vectorSize = lhs.GetColumns();
    std::copy(rhs, rhs + vectorSize, result);
    int n             = lhs.GetRows();
    const DataType *a = lhs.GetRawPtr();
    DataType *x       = result;
    int incx          = 1;
 
    Blas::Tpmv('U', lhs.GetTransposeFlag(), 'N', n, a, x, incx);
}

References CellMLToNektar.pycml::copy(), Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetRawPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetTransposeFlag(), and Blas::Tpmv().

Referenced by Multiply(), and NekMultiplyUpperTriangularMatrix().

◆ NekMultiplyUpperTriangularMatrix() [2/3]

template<typename DataType , typename LhsDataType , typename MatrixType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const DataType *	rhs
	)

Definition at line 456 of file MatrixVectorMultiplication.cpp.

{
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        DataType accum = DataType(0);
        for (unsigned int j = i; j < lhs.GetColumns(); ++j)
        {
            accum += lhs(i, j) * rhs[j];
        }
        result[i] = accum;
    }
}

◆ NekMultiplyUpperTriangularMatrix() [3/3]

template<typename DataType >

void Nektar::NekMultiplyUpperTriangularMatrix	(	DataType *	result,
		const NekMatrix< NekMatrix< DataType, StandardMatrixTag >, ScaledMatrixTag > &	lhs,
		const DataType *	rhs
	)

Definition at line 441 of file MatrixVectorMultiplication.cpp.

{
    NekMultiplyUpperTriangularMatrix(result, *lhs.GetOwnedMatrix(), rhs);
 
    for (unsigned int i = 0; i < lhs.GetColumns(); ++i)
    {
        result[i] *= lhs.Scale();
    }
}

References NekMultiplyUpperTriangularMatrix().

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [1/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	AddEqual	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [2/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(1,(const NekDouble &))
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [3/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(1,(const NekDouble &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [4/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(NekVector< NekDouble >))	,
		(0,())	,
		(1,(const NekVector< NekDouble > &))
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [5/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(1,(const NekDouble &))
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [6/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(2,(DNekMat &, const NekDouble &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [7/11]

Nektar::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() [8/11]

Nektar::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() [9/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	MultiplyEqual	,
		(1,(DNekMat &))	,
		(1,(void))	,
		(0,())	,
		(1,(const NekDouble &))
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [10/11]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	SubtractEqual	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX() [11/11]

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX	(	SubtractEqualNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [1/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Add	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [2/6]

Nektar::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() [3/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Multiply	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [4/6]

Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	Subtract	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(DNekMat))	,
		(0,())	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES() [5/6]

Nektar::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() [6/6]

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES	(	SubtractNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ Normalize() [1/3]

template<typename DataType >

void Nektar::Normalize ( NekVector< DataType > & v )

Definition at line 1214 of file NekVector.cpp.

{
    DataType m = v.Magnitude();
    if (m > DataType(0))
    {
        v /= m;
    }
}

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

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

◆ Normalize() [2/3]

template void Nektar::Normalize ( NekVector< NekDouble > & v )

◆ Normalize() [3/3]

template void Nektar::Normalize ( NekVector< NekSingle > & v )

◆ operator!=() [1/6]

template<typename T1 , typename T2 >

bool Nektar::operator!=	(	const Array< OneD, T1 > &	lhs,
		const Array< OneD, T2 > &	rhs
	)

Definition at line 880 of file BasicUtils/SharedArray.hpp.

{
    return !(lhs == rhs);
}

◆ operator!=() [2/6]

template<typename T1 , typename T2 >

bool Nektar::operator!=	(	const Array< TwoD, T1 > &	lhs,
		const Array< TwoD, T2 > &	rhs
	)

Definition at line 981 of file BasicUtils/SharedArray.hpp.

{
    return !(lhs == rhs);
}

◆ operator!=() [3/6]

template<typename DataType >

bool Nektar::operator!=	(	const MemoryManager< DataType > &	lhs,
		const MemoryManager< DataType > &	rhs
	)

Definition at line 306 of file NekMemoryManager.hpp.

{
    return !(lhs == rhs);
}

◆ operator!=() [4/6]

template<typename DataType >

bool Nektar::operator!=	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1049 of file NekVector.cpp.

{
    return !(lhs == rhs);
}

◆ operator!=() [5/6]

template bool Nektar::operator!=	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ operator!=() [6/6]

template bool Nektar::operator!=	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ operator*() [1/9]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag > Nektar::operator*	(	const DataType &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 118 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [2/9]

template<typename DataType >

NekVector< DataType > Nektar::operator*	(	const NekDouble &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 314 of file NekVector.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [3/9]

template<typename LhsDataType , typename RhsDataType , typename LhsMatrixType , typename RhsMatrixType >

NekMatrix< typename std::remove_const< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType >::type, StandardMatrixTag > Nektar::operator*	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 278 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [4/9]

template<typename DataType , typename LhsDataType , typename MatrixType >

NekVector< DataType > Nektar::operator*	(	const NekMatrix< LhsDataType, MatrixType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 72 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [5/9]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

NekMatrix< typename NekMatrix< RhsDataType, RhsMatrixType >::NumberType, StandardMatrixTag > Nektar::operator*	(	const NekMatrix< RhsDataType, RhsMatrixType > &	lhs,
		const DataType &	rhs
	)

Definition at line 126 of file MatrixOperations.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [6/9]

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.

{
    NekPoint<DataType> result(lhs);
    result *= rhs;
    return result;
}

◆ operator*() [7/9]

template<typename DataType >

NekVector< DataType > Nektar::operator*	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 307 of file NekVector.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [8/9]

template<typename DataType >

NekVector< DataType > Nektar::operator*	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 321 of file NekVector.hpp.

{
    return Multiply(lhs, rhs);
}

References Multiply().

◆ operator*() [9/9]

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.

{
    NekPoint<DataType> result(rhs);
    result *= lhs;
    return result;
}

◆ operator+() [1/7]

template<typename DataType >

Array< OneD, DataType > Nektar::operator+	(	const Array< OneD, DataType > &	lhs,
		typename Array< OneD, DataType >::size_type	offset
	)

Definition at line 886 of file BasicUtils/SharedArray.hpp.

{
    return Array<OneD, const DataType>::CreateWithOffset(lhs, offset);
}

◆ operator+() [2/7]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::operator+	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 309 of file MatrixOperations.hpp.

{
    return Add(lhs, rhs);
}

References Add().

◆ operator+() [3/7]

template<typename DataType >

NekPoint< DataType > Nektar::operator+	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 376 of file NekPoint.hpp.

{
    NekPoint<DataType> result(lhs);
    result += rhs;
    return result;
}

◆ operator+() [4/7]

template<typename DataType >

NekPoint< DataType > Nektar::operator+	(	const NekPoint< DataType > &	lhs,
		typename boost::call_traits< DataType >::const_reference	rhs
	)

Definition at line 395 of file NekPoint.hpp.

{
    NekPoint<DataType> result(lhs);
    result += rhs;
    return result;
}

◆ operator+() [5/7]

template<typename DataType >

NekVector< DataType > Nektar::operator+	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 335 of file NekVector.hpp.

{
    return Add(lhs, rhs);
}

References Add().

◆ operator+() [6/7]

template<typename DataType >

Array< OneD, DataType > Nektar::operator+	(	typename Array< OneD, DataType >::size_type	offset,
		const Array< OneD, DataType > &	rhs
	)

Definition at line 894 of file BasicUtils/SharedArray.hpp.

{
    return Array<OneD, const DataType>::CreateWithOffset(rhs, offset);
}

◆ operator+() [7/7]

template<typename DataType >

NekPoint< DataType > Nektar::operator+	(	typename boost::call_traits< DataType >::const_reference	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 385 of file NekPoint.hpp.

{
    NekPoint<DataType> result(rhs);
    result += lhs;
    return result;
}

◆ operator-() [1/5]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::operator-	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 359 of file MatrixOperations.hpp.

{
    return Subtract(lhs, rhs);
}

References Subtract().

◆ operator-() [2/5]

template<typename DataType >

NekPoint< DataType > Nektar::operator-	(	const NekPoint< DataType > &	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 405 of file NekPoint.hpp.

{
    NekPoint<DataType> result(lhs);
    result -= rhs;
    return result;
}

◆ operator-() [3/5]

template<typename DataType >

NekPoint< DataType > Nektar::operator-	(	const NekPoint< DataType > &	lhs,
		typename boost::call_traits< DataType >::const_reference	rhs
	)

Definition at line 424 of file NekPoint.hpp.

{
    NekPoint<DataType> result(lhs);
    result -= rhs;
    return result;
}

◆ operator-() [4/5]

template<typename DataType >

NekVector< DataType > Nektar::operator-	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 342 of file NekVector.hpp.

{
    return Subtract(lhs, rhs);
}

References Subtract().

◆ operator-() [5/5]

template<typename DataType >

NekPoint< DataType > Nektar::operator-	(	typename boost::call_traits< DataType >::const_reference	lhs,
		const NekPoint< DataType > &	rhs
	)

Definition at line 414 of file NekPoint.hpp.

{
    NekPoint<DataType> result(-rhs);
    result += lhs;
    return result;
}

◆ operator/() [1/2]

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.

{
    NekPoint<DataType> result(lhs);
    result /= rhs;
    return result;
}

◆ operator/() [2/2]

template<typename DataType >

NekVector< DataType > Nektar::operator/	(	const NekVector< DataType > &	lhs,
		const NekDouble &	rhs
	)

Definition at line 328 of file NekVector.hpp.

{
    return Divide(lhs, rhs);
}

References Divide().

◆ operator<<() [1/10]

template<typename T >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const CountedObject< T > &	lhs
	)

Definition at line 155 of file CountedObject.h.

{
    os << lhs.GetValue();
    return os;
}

References Nektar::CountedObject< DerivedType >::GetValue().

◆ operator<<() [2/10]

template<typename DataType , typename FormType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekMatrix< DataType, FormType > &	rhs
	)

Definition at line 49 of file NekMatrix.hpp.

{
    int oswidth     = 9;
    int osprecision = 6;
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        os << "[";
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << rhs(i, j);
            if (j != rhs.GetColumns() - 1)
            {
                os << ", ";
            }
        }
        os << "]";
        if (i != rhs.GetRows() - 1)
        {
            os << std::endl;
        }
    }
    return os;
}

◆ operator<<() [3/10]

template<typename DataType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekPoint< DataType > &	p
	)

Definition at line 499 of file NekPoint.hpp.

{
    os << p.AsString();
    return os;
}

References CellMLToNektar.cellml_metadata::p.

◆ operator<<() [4/10]

template<typename SparseStorageType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseDiagBlkMatrix< SparseStorageType > &	rhs
	)

Definition at line 110 of file SparseUtils.cpp.

{
    int oswidth     = 9;
    int osprecision = 6;
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        os << "[";
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << rhs(i, j);
            if (j != rhs.GetColumns() - 1)
            {
                os << ", ";
            }
        }
        os << "]";
        if (i != rhs.GetRows() - 1)
        {
            os << std::endl;
        }
    }
    return os;
}

References Nektar::NekSparseDiagBlkMatrix< SparseStorageType >::GetColumns(), and Nektar::NekSparseDiagBlkMatrix< SparseStorageType >::GetRows().

◆ operator<<() [5/10]

template std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseDiagBlkMatrix< StorageSmvBsr< NekDouble > > &	rhs
	)

◆ operator<<() [6/10]

template<typename SparseStorageType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseMatrix< SparseStorageType > &	rhs
	)

Definition at line 81 of file SparseUtils.cpp.

{
    int oswidth     = 9;
    int osprecision = 6;
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        os << "[";
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            os.width(oswidth);
            os.precision(osprecision);
            os << rhs(i, j);
            if (j != rhs.GetColumns() - 1)
            {
                os << ", ";
            }
        }
        os << "]";
        if (i != rhs.GetRows() - 1)
        {
            os << std::endl;
        }
    }
    return os;
}

References Nektar::NekSparseMatrix< SparseStorageType >::GetColumns(), and Nektar::NekSparseMatrix< SparseStorageType >::GetRows().

◆ operator<<() [7/10]

template std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekSparseMatrix< StorageSmvBsr< NekDouble > > &	rhs
	)

◆ operator<<() [8/10]

template<typename DataType >

std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekVector< DataType > &	rhs
	)

Definition at line 982 of file NekVector.cpp.

{
    os << rhs.AsString();
    return os;
}

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

◆ operator<<() [9/10]

template std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekVector< NekDouble > &	rhs
	)

◆ operator<<() [10/10]

template std::ostream & Nektar::operator<<	(	std::ostream &	os,
		const NekVector< NekSingle > &	rhs
	)

◆ operator==() [1/6]

template<typename T1 , typename T2 >

bool Nektar::operator==	(	const Array< OneD, T1 > &	lhs,
		const Array< OneD, T2 > &	rhs
	)

Definition at line 855 of file BasicUtils/SharedArray.hpp.

{
    if (lhs.size() != rhs.size())
    {
        return false;
    }
 
    if (lhs.data() == rhs.data())
    {
        return true;
    }
 
    typename Array<OneD, T1>::size_type size_value(lhs.size());
    for (typename Array<OneD, T1>::size_type i = 0; i < size_value; ++i)
    {
        if (!IsEqual(lhs[i], rhs[i]))
        {
            return false;
        }
    }
 
    return true;
}

References IsEqual().

◆ operator==() [2/6]

template<typename T1 , typename T2 >

bool Nektar::operator==	(	const Array< TwoD, T1 > &	lhs,
		const Array< TwoD, T2 > &	rhs
	)

Definition at line 952 of file BasicUtils/SharedArray.hpp.

{
    if ((lhs.GetRows() != rhs.GetRows()) ||
        (lhs.GetColumns() != rhs.GetColumns()))
    {
        return false;
    }
 
    if (lhs.data() == rhs.data())
    {
        return true;
    }
 
    for (typename Array<OneD, T1>::size_type i = 0; i < lhs.GetRows(); ++i)
    {
        for (typename Array<OneD, T1>::size_type j = 0; j < lhs.GetColumns();
             ++j)
        {
            if (!IsEqual(lhs[i][j], rhs[i][j]))
            {
                return false;
            }
        }
    }
 
    return true;
}

References IsEqual().

◆ operator==() [3/6]

template<typename DataType >

bool Nektar::operator==	(	const MemoryManager< DataType > &	lhs,
		const MemoryManager< DataType > &	rhs
	)

Definition at line 299 of file NekMemoryManager.hpp.

{
    return true;
}

◆ operator==() [4/6]

template<typename DataType >

bool Nektar::operator==	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 1032 of file NekVector.cpp.

{
    if (lhs.GetDimension() != rhs.GetDimension())
    {
        return false;
    }
 
    return std::equal(lhs.begin(), lhs.end(), rhs.begin());
}

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

◆ operator==() [5/6]

template bool Nektar::operator==	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ operator==() [6/6]

template bool Nektar::operator==	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ operator>>()

template<typename DataType , typename FormType >

std::ostream & Nektar::operator>>	(	std::ostream &	os,
		const NekMatrix< DataType, FormType > &	rhs
	)

Definition at line 78 of file NekMatrix.hpp.

{
    NekDouble tol = 1e-12;
    os << "[" << std::endl;
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            if ((NekDouble)rhs(i, j) > tol)
            {
                os << '+';
            }
            else if ((NekDouble)rhs(i, j) < -tol)
            {
                os << '*';
            }
            else
            {
                os << '-';
            }
        }
        if (i != rhs.GetRows() - 1)
        {
            os << std::endl;
        }
    }
    os << "]" << std::endl;
    return os;
}

◆ prefun()

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

g	Array of gamma parameters.
p	Pressure at current iteration.
dk	Density (left or right state)
pk	Pressure (left or right state)
ck	Sound speed (left or right state)
f	Computed pressure (shock).
fd	Computed pressure (rarefaction).

Definition at line 117 of file ExactSolverToro.cpp.

{
    if (p <= pk)
    {
        // Rarefaction wave
        NekDouble prat = p / pk;
        f              = g[4] * ck * (pow(prat, g[1]) - 1.0);
        fd             = pow(prat, -g[2]) / (dk * ck);
    }
    else
    {
        // Shock wave
        NekDouble ak  = g[5] / dk;
        NekDouble bk  = g[6] * pk;
        NekDouble qrt = sqrt(ak / (bk + p));
        f             = (p - pk) * qrt;
        fd            = (1.0 - 0.5 * (p - pk) / (bk + p)) * qrt;
    }
}

References CellMLToNektar.cellml_metadata::p, and tinysimd::sqrt().

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

◆ RoeKernel()

template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>

void Nektar::RoeKernel	(	T &	rhoL,
		T &	rhouL,
		T &	rhovL,
		T &	rhowL,
		T &	EL,
		T &	rhoR,
		T &	rhouR,
		T &	rhovR,
		T &	rhowR,
		T &	ER,
		T &	rhof,
		T &	rhouf,
		T &	rhovf,
		T &	rhowf,
		T &	Ef,
		NekDouble	gamma
	)

inline

Definition at line 73 of file RoeSolver.h.

{
    // Left and right velocities
    T uL = rhouL / rhoL;
    T vL = rhovL / rhoL;
    T wL = rhowL / rhoL;
    T uR = rhouR / rhoR;
    T vR = rhovR / rhoR;
    T wR = rhowR / rhoR;
 
    // Left and right pressures
    T pL = (gamma - 1.0) * (EL - 0.5 * (rhouL * uL + rhovL * vL + rhowL * wL));
    T pR = (gamma - 1.0) * (ER - 0.5 * (rhouR * uR + rhovR * vR + rhowR * wR));
 
    // Left and right enthalpy
    T hL = (EL + pL) / rhoL;
    T hR = (ER + pR) / rhoR;
 
    // Square root of rhoL and rhoR.
    T srL  = sqrt(rhoL);
    T srR  = sqrt(rhoR);
    T srLR = srL + srR;
 
    // Velocity, enthalpy and sound speed Roe averages (equation 11.60).
    T uRoe = (srL * uL + srR * uR) / srLR;
    T vRoe = (srL * vL + srR * vR) / srLR;
    T wRoe = (srL * wL + srR * wR) / srLR;
    T hRoe = (srL * hL + srR * hR) / srLR;
    T URoe = (uRoe * uRoe + vRoe * vRoe + wRoe * wRoe);
    T cRoe = sqrt((gamma - 1.0) * (hRoe - 0.5 * URoe));
 
    // Compute eigenvectors (equation 11.59).
    T k[5][5] = {{1., uRoe - cRoe, vRoe, wRoe, hRoe - uRoe * cRoe},
                 {1., uRoe, vRoe, wRoe, 0.5 * URoe},
                 {0., 0., 1., 0., vRoe},
                 {0., 0., 0., 1., wRoe},
                 {1., uRoe + cRoe, vRoe, wRoe, hRoe + uRoe * cRoe}};
 
    // Calculate jumps \Delta u_i (defined preceding equation 11.67).
    T jump[5] = {rhoR - rhoL, rhouR - rhouL, rhovR - rhovL, rhowR - rhowL,
                 ER - EL};
 
    // Define \Delta u_5 (equation 11.70).
    T jumpbar = jump[4] - (jump[2] - vRoe * jump[0]) * vRoe -
                (jump[3] - wRoe * jump[0]) * wRoe;
 
    // Compute wave amplitudes (equations 11.68, 11.69).
    T alpha[5];
    alpha[1] = (gamma - 1.0) *
               (jump[0] * (hRoe - uRoe * uRoe) + uRoe * jump[1] - jumpbar) /
               (cRoe * cRoe);
    alpha[0] =
        (jump[0] * (uRoe + cRoe) - jump[1] - cRoe * alpha[1]) / (2.0 * cRoe);
    alpha[4] = jump[0] - (alpha[0] + alpha[1]);
    alpha[2] = jump[2] - vRoe * jump[0];
    alpha[3] = jump[3] - wRoe * jump[0];
 
    // Compute average of left and right fluxes needed for equation 11.29.
    rhof  = 0.5 * (rhoL * uL + rhoR * uR);
    rhouf = 0.5 * (pL + rhoL * uL * uL + pR + rhoR * uR * uR);
    rhovf = 0.5 * (rhoL * uL * vL + rhoR * uR * vR);
    rhowf = 0.5 * (rhoL * uL * wL + rhoR * uR * wR);
    Ef    = 0.5 * (uL * (EL + pL) + uR * (ER + pR));
 
    // Needed to get right overload resolution for std::abs
    using std::abs;
 
    // Compute eigenvalues \lambda_i (equation 11.58).
    T uRoeAbs   = abs(uRoe);
    T lambda[5] = {abs(uRoe - cRoe), uRoeAbs, uRoeAbs, uRoeAbs,
                   abs(uRoe + cRoe)};
 
    // Finally perform summation (11.29).
    for (size_t i = 0; i < 5; ++i)
    {
        uRoeAbs = 0.5 * alpha[i] * lambda[i];
 
        rhof -= uRoeAbs * k[i][0];
        rhouf -= uRoeAbs * k[i][1];
        rhovf -= uRoeAbs * k[i][2];
        rhowf -= uRoeAbs * k[i][3];
        Ef -= uRoeAbs * k[i][4];
    }
}

References tinysimd::abs(), and tinysimd::sqrt().

Referenced by main(), Nektar::RoeSolver::v_ArraySolve(), Nektar::RoeSolver::v_PointSolve(), and Nektar::RoeSolverSIMD::v_Solve().

◆ RunAllAddCombinations()

template<typename LhsScaledInnerMatrixType , typename LhsBlockInnerMatrixType , typename RhsScaledInnerMatrixType , typename RhsBlockInnerMatrixType >

void Nektar::RunAllAddCombinations	(	const NekMatrix< NekDouble, StandardMatrixTag > &	l1,
		const NekMatrix< NekMatrix< NekDouble, LhsScaledInnerMatrixType >, ScaledMatrixTag > &	l2,
		const NekMatrix< NekMatrix< NekDouble, LhsBlockInnerMatrixType >, BlockMatrixTag > &	l3,
		const NekMatrix< NekDouble, StandardMatrixTag > &	r1,
		const NekMatrix< NekMatrix< NekDouble, RhsScaledInnerMatrixType >, ScaledMatrixTag > &	r2,
		const NekMatrix< NekMatrix< NekDouble, RhsBlockInnerMatrixType >, BlockMatrixTag > &	r3,
		const NekMatrix< NekDouble, StandardMatrixTag > &	result
	)

Definition at line 47 of file TestCombinationRunner.h.

{
    BOOST_CHECK_EQUAL(l1 + r1, result);
    BOOST_CHECK_EQUAL(l1 + r2, result);
    BOOST_CHECK_EQUAL(l1 + r3, result);
    BOOST_CHECK_EQUAL(l2 + r1, result);
    BOOST_CHECK_EQUAL(l2 + r2, result);
    BOOST_CHECK_EQUAL(l2 + r3, result);
    BOOST_CHECK_EQUAL(l3 + r1, result);
    BOOST_CHECK_EQUAL(l3 + r2, result);
    BOOST_CHECK_EQUAL(l3 + r3, result);
}

Referenced by Nektar::StandardMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE(), and Nektar::MatrixOperationTests::BOOST_AUTO_TEST_CASE().

◆ RunAllSubCombinations()

template<typename LhsScaledInnerMatrixType , typename LhsBlockInnerMatrixType , typename RhsScaledInnerMatrixType , typename RhsBlockInnerMatrixType >

void Nektar::RunAllSubCombinations	(	const NekMatrix< NekDouble, StandardMatrixTag > &	l1,
		const NekMatrix< NekMatrix< NekDouble, LhsScaledInnerMatrixType >, ScaledMatrixTag > &	l2,
		const NekMatrix< NekMatrix< NekDouble, LhsBlockInnerMatrixType >, BlockMatrixTag > &	l3,
		const NekMatrix< NekDouble, StandardMatrixTag > &	r1,
		const NekMatrix< NekMatrix< NekDouble, RhsScaledInnerMatrixType >, ScaledMatrixTag > &	r2,
		const NekMatrix< NekMatrix< NekDouble, RhsBlockInnerMatrixType >, BlockMatrixTag > &	r3,
		const NekMatrix< NekDouble, StandardMatrixTag > &	result
	)

Definition at line 73 of file TestCombinationRunner.h.

{
    BOOST_CHECK_EQUAL(l1 - r1, result);
    BOOST_CHECK_EQUAL(l1 - r2, result);
    BOOST_CHECK_EQUAL(l1 - r3, result);
    BOOST_CHECK_EQUAL(l2 - r1, result);
    BOOST_CHECK_EQUAL(l2 - r2, result);
    BOOST_CHECK_EQUAL(l2 - r3, result);
    BOOST_CHECK_EQUAL(l3 - r1, result);
    BOOST_CHECK_EQUAL(l3 - r2, result);
    BOOST_CHECK_EQUAL(l3 - r3, result);
}

Referenced by Nektar::MatrixSubtractionTests::BOOST_AUTO_TEST_CASE(), and Nektar::StandardMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE().

◆ Subtract() [1/9]

template<typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat NekMatrix< typename NekMatrix< LhsDataType, LhsMatrixType >::NumberType, StandardMatrixTag > Nektar::Subtract	(	const NekMatrix< LhsDataType, LhsMatrixType > &	lhs,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 483 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    lhs.GetColumns());
    Subtract(result, lhs, rhs);
    return result;
}

References Subtract().

◆ Subtract() [2/9]

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 483 of file MatrixOperations.cpp.

{
    typedef
        typename NekMatrix<LhsDataType, LhsMatrixType>::NumberType NumberType;
    NekMatrix<NumberType, StandardMatrixTag> result(lhs.GetRows(),
                                                    lhs.GetColumns());
    Subtract(result, lhs, rhs);
    return result;
}

References Subtract().

◆ Subtract() [3/9]

template<typename DataType >

NekVector< DataType > Nektar::Subtract	(	const NekVector< DataType > &	lhs,
		const NekVector< DataType > &	rhs
	)

Definition at line 660 of file NekVector.cpp.

{
    NekVector<DataType> result(lhs.GetDimension());
    Subtract(result, lhs, rhs);
    return result;
}

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

◆ Subtract() [4/9]

template NekVector< NekDouble > Nektar::Subtract	(	const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Subtract() [5/9]

template NekVector< NekSingle > Nektar::Subtract	(	const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

Referenced by Subtract().

◆ Subtract() [6/9]

template<typename DataType , typename LhsDataType , typename LhsMatrixType , typename RhsDataType , typename RhsMatrixType >

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

Definition at line 355 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(lhs.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be subtracted."));
    ASSERTL1(lhs.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(lhs.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be subtracted."));
 
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            result(i, j) = lhs(i, j) - rhs(i, j);
        }
    }
}

References ASSERTL1.

Referenced by operator-(), and Subtract().

◆ Subtract() [7/9]

template void Nektar::Subtract	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ Subtract() [8/9]

template void Nektar::Subtract	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ Subtract() [9/9]

template<typename ResultDataType , typename InputDataType >

void Nektar::Subtract	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 576 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
    typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
    const unsigned int ldim                               = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = lhs_buf[i] - rhs_buf[i];
    }
}

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

◆ SubtractEqual() [1/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

SNekMat SNekMat void Nektar::SubtractEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 419 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be subtracted."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be subtracted."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) -= rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ SubtractEqual() [2/5]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::SubtractEqual	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 419 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be subtracted."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be subtracted."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) -= rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ SubtractEqual() [3/5]

template void Nektar::SubtractEqual	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

◆ SubtractEqual() [4/5]

template void Nektar::SubtractEqual	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

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

◆ SubtractEqual() [5/5]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractEqual	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 622 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
    const unsigned int rdim                               = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] -= rhs_buf[i];
    }
}

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

◆ SubtractEqualNegatedLhs() [1/4]

template<typename DataType , typename RhsDataType , typename RhsMatrixType >

void Nektar::SubtractEqualNegatedLhs	(	NekMatrix< DataType, StandardMatrixTag > &	result,
		const NekMatrix< RhsDataType, RhsMatrixType > &	rhs
	)

Definition at line 443 of file MatrixOperations.cpp.

{
    ASSERTL1(result.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(result.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be subtracted."));
    ASSERTL1(result.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(result.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be subtracted."));
 
    for (unsigned int i = 0; i < rhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < rhs.GetColumns(); ++j)
        {
            result(i, j) = -result(i, j) - rhs(i, j);
        }
    }
}

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

◆ SubtractEqualNegatedLhs() [2/4]

template void Nektar::SubtractEqualNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	rhs
	)

◆ SubtractEqualNegatedLhs() [3/4]

template void Nektar::SubtractEqualNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	rhs
	)

◆ SubtractEqualNegatedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractEqualNegatedLhs	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 635 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
    const unsigned int rdim                               = rhs.GetDimension();
    for (int i = 0; i < rdim; ++i)
    {
        r_buf[i] = -r_buf[i] - rhs_buf[i];
    }
}

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

◆ SubtractNegatedLhs() [1/4]

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 381 of file MatrixOperations.cpp.

{
    ASSERTL1(lhs.GetRows() == rhs.GetRows(),
             std::string("Matrices with different row counts  ") +
                 std::to_string(lhs.GetRows()) + std::string(" and ") +
                 std::to_string(rhs.GetRows()) +
                 std::string(" can't be subtracted."));
    ASSERTL1(lhs.GetColumns() == rhs.GetColumns(),
             std::string("Matrices with different column counts  ") +
                 std::to_string(lhs.GetColumns()) + std::string(" and ") +
                 std::to_string(rhs.GetColumns()) +
                 std::string(" can't be subtracted."));
 
    for (unsigned int i = 0; i < lhs.GetRows(); ++i)
    {
        for (unsigned int j = 0; j < lhs.GetColumns(); ++j)
        {
            result(i, j) = -lhs(i, j) - rhs(i, j);
        }
    }
}

References ASSERTL1.

◆ SubtractNegatedLhs() [2/4]

template void Nektar::SubtractNegatedLhs	(	NekVector< NekDouble > &	result,
		const NekVector< NekDouble > &	lhs,
		const NekVector< NekDouble > &	rhs
	)

◆ SubtractNegatedLhs() [3/4]

template void Nektar::SubtractNegatedLhs	(	NekVector< NekSingle > &	result,
		const NekVector< NekSingle > &	lhs,
		const NekVector< NekSingle > &	rhs
	)

◆ SubtractNegatedLhs() [4/4]

template<typename ResultDataType , typename InputDataType >

void Nektar::SubtractNegatedLhs	(	NekVector< ResultDataType > &	result,
		const NekVector< InputDataType > &	lhs,
		const NekVector< InputDataType > &	rhs
	)

Definition at line 591 of file NekVector.cpp.

{
    ResultDataType *r_buf                                 = result.GetRawPtr();
    typename std::add_const<InputDataType>::type *lhs_buf = lhs.GetRawPtr();
    typename std::add_const<InputDataType>::type *rhs_buf = rhs.GetRawPtr();
    const unsigned int ldim                               = lhs.GetDimension();
    for (int i = 0; i < ldim; ++i)
    {
        r_buf[i] = -lhs_buf[i] - rhs_buf[i];
    }
}

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

◆ Transpose() [1/7]

template<typename DataType >

NekMatrix< DataType, ScaledMatrixTag > Nektar::Transpose ( NekMatrix< DataType, ScaledMatrixTag > & rhs )

Definition at line 221 of file ScaledMatrix.cpp.

{
    NekMatrix<DataType, ScaledMatrixTag> result(rhs);
    result.Transpose();
    return result;
}

◆ Transpose() [2/7]

template<typename DataType >

NekMatrix< DataType, StandardMatrixTag > Nektar::Transpose ( NekMatrix< DataType, StandardMatrixTag > & rhs )

Definition at line 876 of file StandardMatrix.cpp.

{
    NekMatrix<DataType, StandardMatrixTag> result(
        rhs.GetRows(), rhs.GetColumns(), rhs.GetPtr(), eWrapper, rhs.GetType(),
        rhs.GetNumberOfSubDiagonals(), rhs.GetNumberOfSuperDiagonals());
    result.Transpose();
    return result;
}

References eWrapper, Nektar::ConstMatrix< DataType >::GetColumns(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetNumberOfSubDiagonals(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetNumberOfSuperDiagonals(), Nektar::NekMatrix< DataType, StandardMatrixTag >::GetPtr(), Nektar::ConstMatrix< DataType >::GetRows(), Nektar::ConstMatrix< DataType >::GetType(), and Nektar::ConstMatrix< DataType >::Transpose().

◆ Transpose() [3/7]

template<typename InnerMatrixType >

NekMatrix< InnerMatrixType, BlockMatrixTag > Nektar::Transpose ( NekMatrix< InnerMatrixType, BlockMatrixTag > & rhs )

Definition at line 235 of file BlockMatrix.hpp.

{
    NekMatrix<InnerMatrixType, BlockMatrixTag> result(rhs);
    result.Transpose();
    return result;
}

Referenced by Nektar::StandardMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::BlockMatrixUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::FullMatrixOperationsUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::UnitTests::BOOST_AUTO_TEST_CASE(), Nektar::ScaledMatrixUnitTests::BOOST_AUTO_TEST_CASE(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), Nektar::LocalRegions::Expansion3D::CreateMatrix(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::MultiRegions::PreconditionerLowEnergy::v_BuildPreconditioner(), Nektar::LocalRegions::Expansion2D::v_DGDeriv(), Nektar::LocalRegions::Expansion3D::v_DGDeriv(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::LocalRegions::Expansion1D::v_GenMatrix(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), Nektar::MultiRegions::DisContField::v_HelmSolve(), and Nektar::MultiRegions::PreconditionerLowEnergy::v_TransformedSchurCompl().

◆ Transpose() [4/7]

template NekMatrix< NekDouble, StandardMatrixTag > Nektar::Transpose ( NekMatrix< NekDouble, StandardMatrixTag > & rhs )

◆ Transpose() [5/7]

template NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > Nektar::Transpose ( NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > & rhs )

◆ Transpose() [6/7]

template NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > Nektar::Transpose ( NekMatrix< NekMatrix< NekSingle, StandardMatrixTag >, ScaledMatrixTag > & rhs )

◆ Transpose() [7/7]

template NekMatrix< NekSingle, StandardMatrixTag > Nektar::Transpose ( NekMatrix< NekSingle, StandardMatrixTag > & rhs )

Variable Documentation

◆ EigenvaluesAnaMeshesAB2

NekDouble Nektar::EigenvaluesAnaMeshesAB2[6][14]

static

Initial value:

= {
    {18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300,
     212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500,
     579.489600, 656.332100},
    {625.358147, 1196.328877, 1817.986152, 2475.195638, 3162.726621,
     3867.689152, 4595.324620, 5340.967597, 6188.286000, 7399.972000,
     8708.072000, 10111.160000, 11608.000000, 13197.470000},
    {705.738221, 1268.022370, 1883.167893, 2533.621042, 3215.460527,
     3915.574276, 4638.993612, 5380.985954, 6153.131100, 6914.337599,
     7721.969961, 8529.801758, 9326.138300, 10138.712574},
    {733.261678, 1293.053007, 1905.511959, 2553.681869, 3233.562783,
     3932.056639, 4654.037626, 5394.854534, 6165.912400, 6926.174929,
     7732.912435, 8509.531270, 9335.504451, 10147.409120},
    {747.053764, 1305.602041, 1916.689465, 2563.704820, 3242.557000,
     3940.217950, 4661.410438, 5401.601883, 6172.029656, 6931.769221,
     7737.958233, 8514.117977, 9339.576627, 10151.066350},
    {755.354971, 1313.162315, 1923.399136, 2569.711788, 3247.904628,
     3945.042610, 4665.705043, 5405.487354, 6175.462753, 6934.840253,
     7740.605266, 8518.215978, 9343.872193, 10156.126788}}

Definition at line 77 of file CFLtester.h.

◆ EigenvaluesAnaMeshesRK2

NekDouble Nektar::EigenvaluesAnaMeshesRK2[6][14]

static

Initial value:

= {
    {18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300,
     212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500,
     579.489600, 656.332100},
    {557.050244, 1050.871071, 1626.248117, 2260.761693, 2948.760275,
     3677.949231, 4461.704082, 5269.668301, 6188.286000, 7399.972000,
     8708.072000, 10111.160000, 11608.000000, 13197.470000},
    {628.920938, 1115.037602, 1684.555318, 2314.125522, 2997.926601,
     3723.485221, 4504.103288, 5309.152432, 6144.425035, 6997.224333,
     7899.393530, 8799.536577, 9741.728144, 10730.151339},
    {653.448558, 1137.048335, 1704.542817, 2332.448417, 3014.804194,
     3739.158997, 4518.709861, 5322.835874, 6157.188251, 7009.203565,
     7910.587422, 8810.047856, 9751.511668, 10739.355196},
    {665.739421, 1148.083349, 1714.541462, 2341.603048, 3023.189930,
     3746.919933, 4525.868290, 5329.493149, 6163.296851, 7014.864920,
     7915.749155, 8814.796544, 9755.765307, 10668.230508},
    {673.137069, 1154.731489, 1720.543482, 2347.089614, 3028.175778,
     3751.507906, 4508.994826, 5306.299694, 6166.725091, 7017.972766,
     7918.457008, 8818.796544, 9759.765307, 10672.230508}}

Definition at line 97 of file CFLtester.h.

◆ EigenvaluesAnaMeshesRK4

NekDouble Nektar::EigenvaluesAnaMeshesRK4[6][14]

static

Initial value:

= {
    {18.849560, 37.699110, 62.254810, 92.114370, 127.199300, 167.209300,
     212.189900, 261.852900, 316.311600, 375.280200, 438.911800, 506.922500,
     579.489600, 656.332100},
    {606.168101, 1187.787270, 1793.615712, 2391.865039, 2950.786843,
     3487.596192, 4060.011000, 5074.723000, 6188.286000, 7399.972000,
     8708.072000, 10111.160000, 11608.000000, 13197.470000},
    {684.081594, 1260.315774, 1857.923680, 2448.327633, 2999.987783,
     3530.775456, 4073.368829, 4591.645387, 5121.018725, 5647.554500,
     6330.380000, 7341.464000, 8418.710000, 9561.240000},
    {710.760453, 1285.192482, 1879.968339, 2467.708932, 3016.876152,
     3545.638033, 4086.578922, 4603.479913, 5131.656118, 5657.223101,
     6197.802683, 7022.172000, 8034.773000, 9107.511000},
    {724.129308, 1297.665239, 1890.995890, 2477.394447, 3025.267650,
     3552.997300, 4093.052410, 4609.237151, 5136.747279, 5661.792457,
     6397.687000, 7383.760000, 8431.678000, 9540.598000},
    {732.175780, 1305.179484, 1897.615616, 2483.199183, 3030.256925,
     3557.347822, 4096.823380, 4612.552660, 5139.604517, 5664.300842,
     6771.812000, 7388.760000, 8436.678000, 9546.598000}}

Definition at line 117 of file CFLtester.h.

◆ EigenvaluesRegMeshes

NekDouble Nektar::EigenvaluesRegMeshes[10][14]

static

Definition at line 45 of file CFLtester.h.

◆ FlagTypeMap

const char* const Nektar::FlagTypeMap[] = {"UseGlobal"}

String map for FlagType enumeration.

Definition at line 95 of file NektarUnivTypeDefs.hpp.

◆ InitWaveTypeMap

const char* const Nektar::InitWaveTypeMap[]

Initial value:

= {
    "Left", "BothEnd", "Center", "LeftBottomCorner", "Point", "SpiralDock",
}

Definition at line 74 of file MMFDiffusion.h.

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

◆ kAdvectionFormStr

const std::string Nektar::kAdvectionFormStr[]

Initial value:

= {"NoType",
                                         "Convective",
                                         "NonConservative",
                                         "Linearised",
                                         "Adjoint",
                                         "SkewSymmetric"
                                         "NoAdvection"}

Definition at line 105 of file IncNavierStokes.h.

◆ kEquationTypeStr

const std::string Nektar::kEquationTypeStr[]

Initial value:

= {
    "NoType",
    "SteadyStokes",
    "SteadyOseen",
    "SteadyLinearisedNS",
    "UnsteadyStokes",
    "UnsteadyLinearisedNS",
    "UnsteadyNavierStokes",
    "SteadyNavierStokes",
}

Definition at line 81 of file IncNavierStokes.h.

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

◆ NEKTAR_ALL_MATRIX_TYPES_SINGLE

SNekMat Nektar::NEKTAR_ALL_MATRIX_TYPES_SINGLE

Definition at line 61 of file MatrixOperations.cpp.

◆ NEKTAR_BLOCK_MATRIX_TYPES_SINGLE

Nektar::NEKTAR_BLOCK_MATRIX_TYPES_SINGLE

Definition at line 611 of file MatrixVectorMultiplication.cpp.

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_SINGLE_MATRIX(SubtractEqualNegatedLhs	(	AddEqualNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES

SNekMat Nektar::NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs, NEKTAR_ALL_MATRIX_TYPES, NEKTAR_ALL_MATRIX_TYPES,(1,(void)),(1,(DNekMat &)),(0,())) NEKTAR_GENERATE_EXPLICIT_FUNCTION_INSTANTIATION_TWO_MATRICES(SubtractNegatedLhs	(	AddNegatedLhs	,
		NEKTAR_ALL_MATRIX_TYPES	,
		NEKTAR_ALL_MATRIX_TYPES	,
		(1,(void))	,
		(1,(DNekMat &))	,
		(0,())
	)

◆ NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE

Nektar::NEKTAR_STANDARD_AND_SCALED_MATRICES_SINGLE

Definition at line 589 of file MatrixVectorMultiplication.cpp.

◆ NekVector< NekSingle >

Nektar::NekVector< NekSingle >

Definition at line 627 of file MatrixVectorMultiplication.cpp.

◆ NistSpBlasDescra

const int Nektar::NistSpBlasDescra[5][9]

static

Definition at line 44 of file NistSparseDescriptors.hpp.

◆ NullArrayDNekBlkMatSharedPtr

Array<OneD, DNekBlkMatSharedPtr> Nektar::NullArrayDNekBlkMatSharedPtr

static

Definition at line 93 of file NekTypeDefs.hpp.

◆ NullArraySNekBlkMatSharedPtr

Array<OneD, SNekBlkMatSharedPtr> Nektar::NullArraySNekBlkMatSharedPtr

static

Definition at line 134 of file NekTypeDefs.hpp.

◆ NullDNekMatSharedPtr

DNekMatSharedPtr Nektar::NullDNekMatSharedPtr

static

Definition at line 83 of file NekTypeDefs.hpp.

Referenced by Nektar::StdRegions::StdExpansion::v_BuildInverseTransformationMatrix(), Nektar::LocalRegions::Expansion::v_BuildTransformationMatrix(), Nektar::LocalRegions::Expansion3D::v_BuildTransformationMatrix(), and Nektar::LocalRegions::Expansion::v_BuildVertexMatrix().

◆ NullDNekScalBlkMatSharedPtr

DNekScalBlkMatSharedPtr Nektar::NullDNekScalBlkMatSharedPtr

static

Definition at line 85 of file NekTypeDefs.hpp.

Referenced by Nektar::StdRegions::StdExpansion::v_GetLocStaticCondMatrix().

◆ NullDNekScalMatSharedPtr

DNekScalMatSharedPtr Nektar::NullDNekScalMatSharedPtr

static

Definition at line 84 of file NekTypeDefs.hpp.

Referenced by Nektar::LocalRegions::Expansion::v_GetLocMatrix().

◆ NullInt1DArray

Array<OneD, int> Nektar::NullInt1DArray

static

Definition at line 926 of file BasicUtils/SharedArray.hpp.

Referenced by Nektar::LibUtilities::FieldIOHdf5::v_Import(), and Nektar::LibUtilities::FieldIOXml::v_Import().

◆ NullNekDouble1DArray

Array<OneD, NekDouble> Nektar::NullNekDouble1DArray

static

Definition at line 927 of file BasicUtils/SharedArray.hpp.

◆ NullNekDoubleArrayOfArray

Array<OneD, Array<OneD, NekDouble> > Nektar::NullNekDoubleArrayOfArray

static

Definition at line 928 of file BasicUtils/SharedArray.hpp.

◆ NullNekDoubleTensorOfArray3D

Array<OneD, Array<OneD, Array<OneD, NekDouble> > > Nektar::NullNekDoubleTensorOfArray3D

static

Definition at line 930 of file BasicUtils/SharedArray.hpp.

Referenced by Nektar::CFSImplicit::CalcTraceNumericalFlux(), Nektar::LibUtilities::NoSchemeTimeIntegrationScheme::v_GetSolutionVector(), and Nektar::LibUtilities::NoSchemeTimeIntegrationScheme::v_UpdateSolutionVector().

◆ NullPulseWaveBoundarySharedPtr

PulseWaveBoundarySharedPtr Nektar::NullPulseWaveBoundarySharedPtr

static

Definition at line 52 of file PulseWaveBoundary.h.

◆ NullPulseWavePressureAreaSharedPtr

PulseWavePressureAreaSharedPtr Nektar::NullPulseWavePressureAreaSharedPtr

static

Definition at line 51 of file PulseWavePressureArea.h.

◆ NullSNekMatSharedPtr

SNekMatSharedPtr Nektar::NullSNekMatSharedPtr

static

Definition at line 130 of file NekTypeDefs.hpp.

◆ NullSNekScalBlkMatSharedPtr

SNekScalBlkMatSharedPtr Nektar::NullSNekScalBlkMatSharedPtr

static

Definition at line 132 of file NekTypeDefs.hpp.

◆ NullSNekScalMatSharedPtr

SNekScalMatSharedPtr Nektar::NullSNekScalMatSharedPtr

static

Definition at line 131 of file NekTypeDefs.hpp.

◆ ProblemTypeMap

const char* const Nektar::ProblemTypeMap[] = {"General", "SolitaryWave"}

Definition at line 51 of file NonlinearPeregrine.h.

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

◆ TestTypeMap

const char *const Nektar::TestTypeMap

Initial value:

= {
    "TestPlane",   "TestCube",  "TestLinearSphere", "TestNonlinearSphere",
    "FHNStandard", "FHNRogers", "FHNAlievPanf",
}

Definition at line 58 of file MMFDiffusion.h.

Referenced by Nektar::MMFAdvection::v_GenerateSummary(), Nektar::MMFDiffusion::v_GenerateSummary(), Nektar::MMFSWE::v_GenerateSummary(), Nektar::MMFDiffusion::v_InitObject(), Nektar::MMFAdvection::v_InitObject(), and Nektar::MMFSWE::v_InitObject().

◆ UpwindTypeMapPulse

const char* const Nektar::UpwindTypeMapPulse[]

Initial value:

= {
    "NoSetPulse",
    "UpwindPulse",
}

Definition at line 54 of file PulseWaveSystem.h.

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

◆ void

SNekMat Nektar::void

Definition at line 61 of file MatrixOperations.cpp.

Referenced by Nektar::LibUtilities::CompressData::ZlibDecode(), and Nektar::LibUtilities::CompressData::ZlibEncode().

◆ VWIIterationTypeMap

const std::string Nektar::VWIIterationTypeMap[]

Initial value:

= {
    "FixedAlpha", "FixedWaveForcing", "FixedAlphaWaveForcing",
    "FixedWaveForcingWithSubIterationOnAlpha"}

Definition at line 62 of file VortexWaveInteraction.h.

Referenced by Nektar::VortexWaveInteraction::VortexWaveInteraction().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AInflowSharedPtr

◆ ArtificialDiffusionFactory

◆ ArtificialDiffusionSharedPtr

◆ BCOEntryType

◆ BCOMatType

◆ BCOMatTypeConstIt

◆ BCOMatTypeSharedPtr

◆ BCOMatVector

◆ BetaPressureAreaSharedPtr

◆ BlkMatDNekBlkMat

◆ BlkMatDNekBlkMatSharedPtr

◆ BlkMatDNekScalBlkMat

◆ BlkMatDNekScalBlkMatSharedPtr

◆ BlkMatSNekBlkMat

◆ BlkMatSNekBlkMatSharedPtr

◆ BlkMatSNekScalBlkMat

◆ BlkMatSNekScalBlkMatSharedPtr

◆ BlockMatrix

◆ BoundaryFactory

◆ CellModelFactory

◆ CellModelSharedPtr

◆ CFSBndCondFactory

◆ CFSBndCondSharedPtr

◆ COOEntryType

◆ COOMatType

◆ COOMatTypeConstIt

◆ COOMatTypeSharedPtr

◆ COOMatVector

◆ CoordType

◆ CoupledAssemblyMapSharedPtr

◆ CoupledLocalToGlobalC0ContMapSharedPtr

◆ CoupledSolverMatrices

◆ DenseMatrix

◆ DiffusionLDGNSSharedPtr

◆ DNekBlkMat

◆ DNekBlkMatSharedPtr

◆ DNekLinSys

◆ DNekLinSysSharedPtr

◆ DNekMat

◆ DNekMatSharedPtr

◆ DNekScalBlkMat

◆ DNekScalBlkMatSharedPtr

◆ DNekScalLinSys

◆ DNekScalLinSysSharedPtr

◆ DNekScalMat

◆ DNekScalMatSharedPtr

◆ DNekVec

◆ EmpiricalPressureAreaSharedPtr

◆ EquationOfStateFactory

◆ EquationOfStateSharedPtr

◆ ExtrapolateFactory

◆ ExtrapolateSharedPtr

◆ FilterAeroForcesSPMSharedPtr

◆ FilterMap

◆ FilterMovingBodySharedPtr

◆ FilterParams

◆ HighOrderOutflowSharedPtr

◆ ImplicitExtrapolateSharedPtr

◆ IncBaseConditionSharedPtr

◆ IncBCFactory

◆ IncBoundaryConditionsSharedPtr

◆ IncNavierStokesSharedPtr

◆ IndexType

◆ IndexVector

◆ InterfacePointShPtr

◆ MappingExtrapolateSharedPtr

◆ MetricSharedPtr

◆ NekComplexDouble

◆ NekDouble

◆ NekInt

◆ NekInt32

◆ NekInt64

◆ NekSingle