Mantid::Kernel Namespace Reference

Namespaces
namespace	ChecksumHelper
	ChecksumHelper : A selection of helper methods for calculating checksums.
namespace	DateAndTimeHelpers
namespace	Detail
namespace	detail
namespace	DynamicPointerCastHelper
namespace	Exception
	The exception classes used by Mantid.
namespace	fft
namespace	Math
namespace	MemoryOptions
namespace	MultiFileNameParsing
namespace	PropertyNexus
	Namespace with helper methods for loading and saving Property's (logs) to NXS files.
namespace	pwvjdetail
namespace	ROI
namespace	Smoothing
namespace	SpinStateHelpers
namespace	spline
namespace	Strings
	Holds support functions for strings.
namespace	Units
	The namespace for concrete units classes.
namespace	Utils
	Utils: General-purpose utility functions that do not belong anywhere else.
namespace	VectorHelper

Classes
class	__save_flags
class	AbstractInstantiator
	The base class for instantiators. More...
class	ArrayBoundedValidator
	Kernel/ArrayBoundedValidator.h. More...
class	ArrayLengthValidator
	ArrayLenghtValidator : Validate length of an array property. More...
class	ArrayOrderedPairsValidator
	Kernel/ArrayOrderedPairsValidator.h. More...
class	ArrayProperty
	Support for a property that holds an array of values. More...
class	AttenuationProfile
class	BinaryFile
	The BinaryFile template is a helper function for loading simple binary files. More...
class	BinaryStreamReader
	Assists with reading a binary file by providing standard overloads for the istream operators (>>) to given types (and vectors of those types). More...
class	BinaryStreamWriter
	Assists with writing a binary file by providing standard overloads for the ostream operators (<<) to given types (and vectors of those types). More...
class	BinFinder
	The BinFinder class is a helper class that allows one to quickly find a bin index for many events. More...
class	BoundedValidator
	BoundedValidator is a validator that requires the values to be between upper or lower bounds, or both. More...
class	Cache
	Cache is a generic caching storage class. More...
struct	CaseInsensitiveCmp
struct	CaseInsensitiveStringComparator
	Functor to provide a case insensitive string comparator. More...
class	CatalogConfigService
class	CatalogInfo
	A class that holds information about catalogs. More...
class	Chainable
	Chainable. More...
class	ChainableFactory
	ChainableFactory : Chain of Responsiblity generic factory. More...
class	ChebyshevPolyFit
	Compute a weighted least-squares polynomial approximations to an arbitrary set of data points. More...
struct	ChebyshevPolynomial
	Evaluates a single Chebyshev polynomial (first kind) for x in range [-1,1]. More...
class	ChebyshevSeries
	Evaluate an approximation to a nth order polynomial using a Chebyshev series through Crenshaw's algorithm to evaluate \(p_n(x) = \Sigma_{i=1}^{n}c_iT_i\) The evaluation is implemented using the reccurrence relations http://mathworld.wolfram.com/ClenshawRecurrenceFormula.html. More...
class	CodeBlockMultipleTimer
class	CodeBlockTimer
class	CompositeValidator
class	ConfigObserver
	The ConfigObserver is used to observe changes in the configuration based on notifications sent from the ConfigService. More...
class	ConfigPropertyObserver
	The ConfigObserver is used to observe changes to the value of a single configuration property based on notifications sent from the ConfigService. More...
class	ConfigServiceImpl
	The ConfigService class provides a simple facade to access the Configuration functionality of the Mantid Framework. More...
class	cow_ptr
	Implements a copy on write data template. More...
class	CPUTimer
	CPUTimer : Timer that uses the CPU time, rather than wall-clock time to measure execution time. More...
struct	CreateUsingNew
	Policy class controlling creation of the singleton Implementation classes should mark their default constructors private and insert a friend declaration for this class, e.g.: More...
class	CubicSpline
	Cubic spline interpolation using GSL. More...
class	DataItem
	This class forms the base class of any item that wishes to be stored in the analysis data service. More...
class	DataService
	DataService stores instances of a given type. More...
class	DateTimeValidator
	Checks that a string contains a timestamp in ISO 8601 format (YYYY-MM-DDTHH:MM:SS.mmmmmm) More...
class	DateValidator
	DateValidator is a validator that validates date, format of valid date is "DD/MM/YYYY" At present, this validator is only available for properties of type std::string This class has written for validating start and end dates of ICat interface. More...
struct	DeltaEMode
	Defines the possible energy transfer modes: More...
struct	Direction
	Describes the direction (within an algorithm) of a Property. More...
class	DirectoryValidator
	DirectoryValidator is a validator that checks that a directory path is valid. More...
class	DiskBuffer
	Buffer objects that need to be written out to disk so as to optimize writing operations. More...
class	DllOpen
	Simple class for opening shared libraries at run-time. More...
class	DynamicFactory
	The dynamic factory is a base dynamic factory for serving up objects in response to requests from other classes. More...
class	EnabledWhenProperty
class	EnumeratedString
class	EnumeratedStringProperty
	A concrete property based on user options of a finite list of strings. More...
class	EnvironmentHistory
	This class stores information about the Environment of the computer used by the framework. More...
class	EqualBinsChecker
	EqualBinsChecker : Checks for evenly spaced bins. More...
class	ErrorReporter
	ErrorReporter : The error reporter is responsible for sending error reports. More...
class	FacilityInfo
	A class that holds information about a facility. More...
class	FeatureUsage
	UsageReporter : The Usage reporter is responsible for collating, and sending all usage data. More...
class	FileDescriptor
	Defines a wrapper around an open file. More...
class	FileValidator
	FileValidator is a validator that checks that a filepath is valid. More...
class	FilteredTimeSeriesProperty
	Templated class that defines a filtered time series but still gives access to the original data. More...
class	FreeBlock
	FreeBlock: a simple class that holds the position and size of block of free space in a file. More...
class	FunctionTask
	A FunctionTask can easily create a Task from a method pointer. More...
class	GitHubApiHelper
	GitHubApiHelper : A helper class for supporting access to the github api through HTTP and HTTPS, inherits from the InternetHelper. More...
class	Glob
	This Glob class uses the glob() method of Poco::Glob class to make it more reliable. More...
class	ICatalogInfo
	ICatalogInfo : An abstract class that holds information about catalogs. More...
class	IndexSet
	IndexSet is a container that can be used to define and access a subset of elements in a larger container such as std::vector. More...
class	INode
	Helper class providing interface to ISAveable. More...
class	Instantiator
	The instantiator is a generic class for creating objects of the template type. More...
class	InstrumentInfo
	A class that holds information about an instrument. More...
class	InternetHelper
	InternetHelper : A helper class for supporting access to resources through HTTP and HTTPS. More...
class	Interpolation
	Provide interpolation over a series of points. More...
class	InverseAngstromsUnit
	Inverse Angstroms unit. More...
class	InverseAngstromsUnitFactory
class	InvisibleProperty
	This property setting object makes a property invisible in the GUI. More...
class	IPropertyManager
	Interface to PropertyManager. More...
class	IPropertySettings
	Interface for modifiers to Property's that specify if they should be enabled or visible in a GUI. More...
class	ISaveable
	An interface for objects that can be cached or saved to disk. More...
class	ITimeSeriesProperty
	A non-templated interface to a TimeSeriesProperty. More...
class	IValidator
	IValidator is the basic interface for all validators for properties. More...
class	LabelUnit
class	LabelUnitFactory
class	LambdaValidator
	LambdaValidator provides a quick way to create custom validation objects using a validator function or lambda expression. More...
class	LegacyNexusDescriptor
	Defines a wrapper around a file whose internal structure can be accessed using the NeXus API. More...
struct	LessOrEqualFunctor
class	LibraryManagerImpl
	Class for opening shared libraries. More...
class	LibraryWrapper
	Class for wrapping a shared library. More...
class	LinearSpline
	Linear interpolation using GSL. More...
class	ListValidator
	ListValidator is a validator that requires the value of a property to be one of a defined list of possibilities. More...
class	LiveListenerInfo
	A class that holds information about a LiveListener connection. More...
class	LogFilter
	This class is for filtering TimeSeriesProperty data. More...
class	Logger
	The Logger class is in charge of the publishing messages from the framework through various channels. More...
class	LogParser
	LogParser parses the instrument log files to select records corresponding to 'RUNNING' instrument status. More...
class	MandatoryValidator
	Validator to check that a property is not left empty. More...
class	MantidVersion
	Class containing static methods to return the Mantid version number and date. More...
class	MaskedProperty
	A property class for masking the properties. More...
class	Material
	A material is defined as being composed of a given element, defined as a PhysicalConstants::NeutronAtom, with the following properties: More...
class	MaterialBuilder
	Create a material from a set of user defined options. More...
class	MaterialXMLParser
	Read an XML definition of a Material and produce a new Material object. More...
class	Matrix
	Numerical Matrix class. More...
class	MatrixProperty
class	MDAxisValidator
	MDAxisValidator is a class that checks the number of MD axes match the number of workspace dimensions, refactoring out the common validation code from several MD algorithms into a common class. More...
class	MDUnit
	MDUnit : Unit type for multidimensional data types. More...
class	MDUnitFactory
	MDUnitFactory : Abstract type. More...
class	MemoryStats
	This class is responsible for memory statistics. More...
class	MersenneTwister
	This implements the Mersenne Twister 19937 pseudo-random number generator algorithm as a specialzation of the PseudoRandomNumberGenerator interface. More...
class	MRUList
	An MRU (most recently used) list keeps record of the last n inserted items, listing first the newer ones. More...
class	MultiFileValidator
	The MultiFileValidator validates a MultiFileProperty, which contains a vector of vectors* of filenames - the meaning of which is discussed in MultiFileProperty.h. More...
class	NDPseudoRandomNumberGenerator
	Defines an ND pseudo-random number generator. More...
class	NDRandomNumberGenerator
	This class defines an interface for N dimensional random number generators. More...
class	NearestNeighbours
class	NetworkProxy
	NetworkProxy : Network proxy utility for getting network proxy information. More...
class	NNDataPoints
	NNDataPoints is a thin RAII wrapper class around the ANNpointArray type. More...
class	normal_distribution
class	NullValidator
	NullValidator is a validator that doesn't. More...
class	OptionalBool
	OptionalBool : Tri-state bool. More...
class	ProgressBase
	ProgressBase. More...
class	Property
	Base class for properties. More...
class	PropertyHistory
	This class stores information about the parameters used by an algorithm. More...
class	PropertyManager
	Property manager helper class. More...
class	PropertyManagerDataServiceImpl
	PropertyManagerDataService Class. More...
class	PropertyManagerOwner
	Kernel/PropertyManagerOwner.h. More...
class	PropertyManagerProperty
class	PropertyWithValue
	The concrete, templated class for properties. More...
class	ProxyInfo
	ProxyInfo : Container for carrying around network proxy information. More...
class	PseudoRandomNumberGenerator
	Defines a 1D pseudo-random number generator, i.e. More...
class	QuasiRandomNumberSequence
	Defines an interface to a quasi-random number sequence. More...
class	Quat
	Class for quaternions. More...
class	QUnit
	QUnit base. More...
class	ReadLock
	Scoped, read-only lock for thread-safe access to DataItems. More...
class	RebinParamsValidator
	Validator to check the format of a vector providing the rebin parameters to an algorithm. More...
class	ReciprocalLatticeUnit
	Dimensionless RLU. More...
class	ReciprocalLatticeUnitFactory
class	RegistrationHelper
	This class is simply used in the subscription of classes into the various factories in Mantid. More...
struct	Rfactor
	R factor for powder data analysis. More...
class	SetDefaultWhenProperty
class	SetValueWhenProperty
class	SingletonHolder
	Manage the lifetime of a class intended to be a singleton. More...
class	SobolSequence
	Defines a generator that produces quasi-random numbers according to a Sobol sequence http://en.wikipedia.org/wiki/Sobol_sequence. More...
class	SpinStateValidator
class	Spline
	Generic spline interpolation base class. More...
class	SplittingInterval
	Class holding a start/end time and a destination for splitting event lists and logs. More...
class	StartsWithValidator
	StartsWithValidator is a validator that requires the value of a property to start with one of the strings in a defined list of possibilities. More...
struct	Statistics
	Simple struct to store statistics. More...
struct	StatOptions
	Controls the computation of statisical data. More...
class	StringContainsValidator
	StringContainsValidator : A validator designed to ensure that a string input contain a given sub string or a set of sub strings. More...
class	StringTokenizer
class	Task
	A Task is a unit of work to be scheduled and run by a ThreadPool. More...
class	ThreadPool
	A Thread Pool implementation that keeps a certain number of threads running (normally, equal to the number of hardware cores available) and schedules tasks to them in the most efficient way possible. More...
class	ThreadPoolRunnable
	ThreadPoolRunnable : Class used by thread pool (and POCO) to run inside a thread. More...
class	ThreadSafeLogIOS
	The base class for ThreadSafeLogStream. More...
class	ThreadSafeLogStream
	The main log stream class implementing an ostream interface to a Logger. More...
class	ThreadSafeLogStreamBuf
	This class implements a threadsafe version of the POCO buffer interface to a Logger's stream object. More...
class	ThreadScheduler
	The ThreadScheduler object defines how tasks are allocated to threads and in what order. More...
class	ThreadSchedulerFIFO
	A First-In-First-Out Thread Scheduler. More...
class	ThreadSchedulerLargestCost
	A Largest Cost Thread Scheduler. More...
class	ThreadSchedulerLIFO
	A Last-In-First-Out Thread Scheduler. More...
class	ThreadSchedulerMutexes
	ThreadSchedulerMutexes : Version of a ThreadSchedulerLargestCost that also makes sure to not try to schedule two tasks with the same mutex at the same time. More...
class	TimeInterval
	Represents a time interval. More...
class	Timer
	A simple class that provides a wall-clock (not processor time) timer. More...
class	TimeROI
	TimeROI : Object that holds information about when the time measurement was active. More...
class	TimeSeriesProperty
	A specialised Property class for holding a series of time-value pairs. More...
struct	TimeSeriesPropertyStatistics
	Struct holding some useful statistics for a TimeSeriesProperty. More...
class	TimeValueUnit
	Class to hold unit value (DateAndTime, T) More...
class	TopicInfo
	TopicInfo : Class that holds information on a kafka topic. More...
class	uniform_int_distribution
class	Unit
	The base units (abstract) class. More...
class	UnitConversion
	A set of static helper methods to perform conversions between units. More...
class	UnitFactoryImpl
	Creates instances of concrete units. More...
class	UnitLabel
	A base-class for the a class that is able to return unit labels in different representations. More...
class	UsageServiceImpl
class	UserCatalogInfo
	UserCatalogInfo : Takes catalog info from the facility (via CatalogInfo), but provides the ability to override the facility defaults based on user preferences. More...
class	UserStringParser
	This class parses a given string into vector of vectors of numbers. More...
class	V2D
	Implements a 2-dimensional vector embedded in a 3D space, i.e. More...
class	V3D
	Class for 3D vectors. More...
class	VisibleWhenProperty
	Same as EnabledWhenProperty, but returns the value for the isVisible() property instead of the isEnabled() property. More...
class	VMDBase
	Simple vector class for multiple dimensions (i.e. More...
class	WriteLock
	Scoped write-lock for thread-safe access to DataItems. More...

Typedefs
template<class T >
using	CaseInsensitiveMap = std::map< std::string, T, CaseInsensitiveStringComparator >
	Alias template for a map data structure that has case insensitive string comparision with a variable value type.
using	CaseSensitiveStringComparator = std::less< std::string >
using	ConfigService = Mantid::Kernel::SingletonHolder< ConfigServiceImpl >
using	ConfigValChangeNotification = Mantid::Kernel::ConfigServiceImpl::ValueChanged
using	ConfigValChangeNotification_ptr = const Poco::AutoPtr< Mantid::Kernel::ConfigServiceImpl::ValueChanged > &
using	DataItem_const_sptr = std::shared_ptr< const DataItem >
	Shared pointer to a const DataItem.
using	DataItem_sptr = std::shared_ptr< DataItem >
	Shared pointer to a DataItem.
using	DataXY = std::pair< double, double >
using	DateAndTimeIter = std::vector< DateAndTime >::iterator
using	DblMatrix = Mantid::Kernel::Matrix< double >
using	FloatMatrix = Mantid::Kernel::Matrix< float >
using	IntMatrix = Mantid::Kernel::Matrix< int >
using	IValidator_sptr = std::shared_ptr< IValidator >
	A shared_ptr to an IValidator.
using	LibraryManager = Mantid::Kernel::SingletonHolder< LibraryManagerImpl >
using	Material_const_sptr = std::shared_ptr< const Material >
	Typedef for a shared pointer to a const object.
using	Material_sptr = std::shared_ptr< Material >
	Typedef for a shared pointer.
using	MDUnit_const_uptr = std::unique_ptr< const MDUnit >
using	MDUnit_uptr = std::unique_ptr< MDUnit >
using	MDUnitFactory_const_uptr = std::unique_ptr< const MDUnitFactory >
using	MDUnitFactory_uptr = std::unique_ptr< MDUnitFactory >
using	OptionalPath = std::optional< std::string >
using	PropertyHistories = std::vector< PropertyHistory_sptr >
using	PropertyHistory_const_sptr = std::shared_ptr< const PropertyHistory >
using	PropertyHistory_sptr = std::shared_ptr< PropertyHistory >
using	PropertyManager_const_sptr = std::shared_ptr< const PropertyManager >
	shared pointer to Mantid::Kernel::PropertyManager(const version)
using	PropertyManager_const_uptr = std::unique_ptr< const PropertyManager >
	unique pointer to Mantid::Kernel::PropertyManager (const version)
using	PropertyManager_sptr = std::shared_ptr< PropertyManager >
	Typedef for a shared pointer to a PropertyManager.
using	PropertyManager_uptr = std::unique_ptr< PropertyManager >
	unique pointer to Mantid::Kernel::PropertyManager
using	PropertyManagerDataService = Mantid::Kernel::SingletonHolder< PropertyManagerDataServiceImpl >
using	PythonObject = boost::python::object
using	SingletonDeleterFn = std::function< void()>
	Type of deleter function.
using	SplittingIntervalVec = std::vector< SplittingInterval >
	A typedef for splitting events according their pulse time.
using	str_pair = std::pair< std::string, std::string >
using	StringListValidator = ListValidator< std::string >
	ListValidator<std::string> is used heavily.
using	time_point_ns = std::chrono::time_point< std::chrono::high_resolution_clock >
using	tokenizer = Mantid::Kernel::StringTokenizer
using	Unit_const_sptr = std::shared_ptr< const Unit >
	Shared pointer to the Unit base class (const version)
using	Unit_sptr = std::shared_ptr< Unit >
	Shared pointer to the Unit base class.
using	UnitFactory = SingletonHolder< UnitFactoryImpl >
using	UnitParametersMap = std::unordered_map< UnitParams, double >
using	UsageService = Mantid::Kernel::SingletonHolder< UsageServiceImpl >
using	VMD = VMDBase< VMD_t >
	Define the VMD as using the double or float data type.
using	VMD_t = float
	Underlying data type for the VMD type.

Enumerations
enum class	CompositeRelation { AND = 0 , OR = 1 }
	A composite validator that can combine any 2+ arbitrary validators together. More...
enum class	DataServiceHidden { Auto , Include , Exclude }
	Flag for whether to include hidden items when returning, Auto queries the class to determine this behavior. More...
enum class	DataServiceSort { Sorted , Unsorted }
	Flag for whether to sort items before returning. More...
enum	eLogicOperator { AND , OR , XOR }
	Enum for use when combining two EnabledWhenPropertyItems. More...
enum	ePropertyCriterion {   IS_DEFAULT , IS_NOT_DEFAULT , IS_EQUAL_TO , IS_NOT_EQUAL_TO ,   IS_MORE_OR_EQ }
	Enum for use in EnabledWhenProperty. More...
enum class	FeatureType { Algorithm , Interface , Feature , Function }
	An enum specifying the 4 possible features types that can be logged in the usage service. More...
enum	MemoryStatsIgnore { MEMORY_STATS_IGNORE_NONE , MEMORY_STATS_IGNORE_SYSTEM , MEMORY_STATS_IGNORE_PROCESS }
	Enmuerate the ignored memory fields. More...
enum	SpecialCoordinateSystem { None = 0 , QLab = 1 , QSample = 2 , HKL = 3 }
	Special coordinate systems for Q3D. More...
enum	TimeSeriesSortStatus { TSUNKNOWN , TSUNSORTED , TSSORTED }
enum class	TopicType {   Event , Chopper , Sample , Run ,   Monitor }
enum class	UnitParams {   l2 , twoTheta , efixed , delta ,   difa , difc , tzero }

Functions
template<typename T >
MANTID_KERNEL_DLL T	absoluteDifference (T const x, T const y)
	Calculate absolute difference between x, y.
template<typename T >
T	absoluteDifference (T const x, T const y)
	ABSOLUTE AND RELATIVE DIFFERENCE.
template<>
void	addingOperator (bool &, const bool &)
template<>
void	addingOperator (OptionalBool &, const OptionalBool &)
template<typename T >
void	addingOperator (std::shared_ptr< T > &, const std::shared_ptr< T > &)
template<typename T >
void	addingOperator (std::vector< T > &lhs, const std::vector< T > &rhs)
template<typename T >
void	addingOperator (T &lhs, const T &rhs)
template<typename T >
void	appendValue (const std::string &strvalue, std::vector< T > &value)
template<typename T , typename BinaryOp >
void	AtomicOp (std::atomic< T > &f, T d, BinaryOp op)
	Uses std::compare_exchange_weak to update the atomic value f = op(f, d) Used to improve parallel scaling in algorithms MDNormDirectSC and MDNormSCD.
bool	canRead (const std::string &filename)
bool	compareTasks (Task *lhs, Task *rhs)
	Method to perform sorting of task lists.
MANTID_KERNEL_DLL PropertyManager_sptr	createPropertyManager (const Json::Value &keyValues)
	Attempt to create a PropertyManager from the Json::Value.
template<typename Type >
Type	decode (const Json::Value &value)
	Attempt to decode the given Json::Value as the given Type.
MANTID_KERNEL_DLL std::unique_ptr< Property >	decodeAsProperty (const std::string &name, const Json::Value &value)
	Attempt to create a Property of the most appropriate type from a string name and Json value object.
MANTID_KERNEL_DLL void	deleteOnExit (const SingletonDeleterFn &func)
	Register the given deleter function to be called at exit.
template<>
std::vector< std::string >	determineAllowedValues (const OptionalBool &, const IValidator &)
template<typename T >
std::vector< std::string >	determineAllowedValues (const T &, const IValidator &validator)
template<typename T >
void	dumpToStream (std::ostream &os, const Kernel::Matrix< T > &matrix, const char delimiter)
	Write a Matrix to a stream.
template<typename ValueType >
Json::Value	encodeAsJson (const Kernel::Matrix< ValueType > &)
	Encode a Matrix as a Json::Value.
MANTID_KERNEL_DLL::Json::Value	encodeAsJson (const OptionalBool &)
	Encode an OptionalBool as a Json::Value.
MANTID_KERNEL_DLL::Json::Value	encodeAsJson (const PropertyManager &propMgr)
	Return the value of the PropertyManager as a Json::Value.
template<typename ValueType >
Json::Value	encodeAsJson (const std::shared_ptr< ValueType > &)
	Encode a shared_ptr by dereferencing a it and encoding its value.
template<>
Json::Value	encodeAsJson (const std::vector< bool > &vectorValue)
	Specialization to encode a std::vector<bool> value as a Json::Value arrayValue type.
template<typename ValueType >
Json::Value	encodeAsJson (const std::vector< ValueType > &vectorValue)
	Encode a std::vector value as a Json::Value arrayValue type.
template<typename ValueType >
Json::Value	encodeAsJson (const ValueType &value)
	Encode a single value as a Json::Value.
template<>
Json::Value	encodeAsJson (PythonObject const &)
	Creates a Json representation of the object.
template<typename T >
MANTID_KERNEL_DLL bool	equals (T const x, T const y)
	Test for equality of doubles using compiler-defined precision.
template<typename T >
bool	equals (T const x, T const y)
	Compare numbers for equality to within machine epsilon.
template<typename T >
bool	equals (T const x, T const y, MADE_FOR_FLOATS)
	Compare floating point numbers for equality to within std::numeric_limits<TYPE>::epsilon precision.
template<typename T >
bool	equals (T const x, T const y, MADE_FOR_INTEGERS)
	Compare integer numbers.
template<typename T >
MANTID_KERNEL_DLL bool	equals (T const x, T const y, std::false_type)
template<typename T >
MANTID_KERNEL_DLL bool	equals (T const x, T const y, std::true_type)
template<typename T >
T	extractToValueVector (const std::string &strvalue)
double	fast_exp (double y)
template<typename T >
void	fillFromStream (std::istream &is, Kernel::Matrix< T > &in, const char delimiter)
	Fill a Matrix from a stream using the given separator.
template<typename T >
int	findSize (const std::vector< T > &value)
	Specialization for properties that are of type vector.
template<typename T >
int	findSize (const T &)
	Specialization for any type, should be appropriate for properties with a single value.
template<typename TYPE >
double	getMedian (const vector< TYPE > &data)
	There are enough special cases in determining the median where it useful to put it in a single function.
template<typename TYPE >
std::vector< double >	getModifiedZscore (const std::vector< TYPE > &data)
	Return the modified Z score values for a dataset.
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< double > (const vector< double > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< float > (const vector< float > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< int > (const vector< int > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< long > (const vector< long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< long long > (const vector< long long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< unsigned int > (const vector< unsigned int > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< unsigned long > (const vector< unsigned long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getModifiedZscore< unsigned long long > (const vector< unsigned long long > &, const bool)
template<typename TYPE >
std::vector< double >	getMomentsAboutMean (const std::vector< TYPE > &x, const std::vector< TYPE > &y, const int maxMoment=3)
	Return the first n-moments of the supplied data.
template<typename TYPE >
std::vector< double >	getMomentsAboutOrigin (const std::vector< TYPE > &x, const std::vector< TYPE > &y, const int maxMoment=3)
	Return the first n-moments of the supplied data.
Rfactor MANTID_KERNEL_DLL	getRFactor (const std::vector< double > &obsI, const std::vector< double > &calI, const std::vector< double > &obsE)
	Return the R-factors (Rwp) of a diffraction pattern data.
template<typename TYPE >
Statistics	getStatistics (const std::vector< TYPE > &data, const unsigned int flags=StatOptions::AllStats)
	Return a statistics object for the given data set.
template<>
DLLExport Statistics	getStatistics< bool > (const vector< bool > &data, const unsigned int flags)
	Getting statistics of a boolean array should just give a bunch of NaNs.
template MANTID_KERNEL_DLL Statistics	getStatistics< double > (const vector< double > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< float > (const vector< float > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< int > (const vector< int > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< long > (const vector< long > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< long long > (const vector< long long > &, const bool)
template<>
DLLExport Statistics	getStatistics< string > (const vector< string > &data, const unsigned int flags)
	Getting statistics of a string array should just give a bunch of NaNs.
template MANTID_KERNEL_DLL Statistics	getStatistics< unsigned int > (const vector< unsigned int > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< unsigned long > (const vector< unsigned long > &, const bool)
template MANTID_KERNEL_DLL Statistics	getStatistics< unsigned long long > (const vector< unsigned long long > &, const bool)
MANTID_KERNEL_DLL std::string	getUnmangledTypeName (const std::type_info &type)
	Return the name corresponding to the mangled string given by typeid.
std::string	getValueFromStdOut (const std::string &orig, const std::string &key)
template<typename TYPE >
std::vector< double >	getWeightedZscore (const vector< TYPE > &data, const vector< TYPE > &weights)
	There are enough special cases in determining the Z score where it useful to put it in a single function.
template<typename TYPE >
std::vector< double >	getZscore (const std::vector< TYPE > &data)
	Return the Z score values for a dataset.
template MANTID_KERNEL_DLL std::vector< double >	getZscore< double > (const vector< double > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< float > (const vector< float > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< int > (const vector< int > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< long > (const vector< long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< long long > (const vector< long long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< unsigned int > (const vector< unsigned int > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< unsigned long > (const vector< unsigned long > &, const bool)
template MANTID_KERNEL_DLL std::vector< double >	getZscore< unsigned long long > (const vector< unsigned long long > &, const bool)
template<typename T >
MANTID_KERNEL_DLL bool	gtEquals (T const x, T const y)
	Test whether x>=y within machine precision.
bool	has_ending (const std::string &value, const std::string &ending)
	Confirm that the value string ends with then ending string.
template<>
MANTID_API_DLL API::IAlgorithm_const_sptr	IPropertyManager::getValue< API::IAlgorithm_const_sptr > (const std::string &name) const
	Get the value of a given property as the declared concrete type (const version)
template<>
MANTID_API_DLL API::IAlgorithm_sptr	IPropertyManager::getValue< API::IAlgorithm_sptr > (const std::string &name) const
	Get the value of a given property as the declared concrete type.
template<>
MANTID_API_DLL Mantid::API::ExperimentInfo_const_sptr	IPropertyManager::getValue< Mantid::API::ExperimentInfo_const_sptr > (const std::string &name) const
template<>
MANTID_API_DLL Mantid::API::ExperimentInfo_sptr	IPropertyManager::getValue< Mantid::API::ExperimentInfo_sptr > (const std::string &name) const
template<>
MANTID_API_DLL Mantid::API::IMDEventWorkspace_const_sptr	IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_const_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.
template<>
MANTID_API_DLL Mantid::API::IMDEventWorkspace_sptr	IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.
template<>
MANTID_API_DLL Mantid::API::IMDHistoWorkspace_const_sptr	IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_const_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDWorkspace_const_sptr> is required.
template<>
MANTID_API_DLL Mantid::API::IMDHistoWorkspace_sptr	IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.
template<>
MANTID_API_DLL Mantid::API::IMDWorkspace_const_sptr	IPropertyManager::getValue< Mantid::API::IMDWorkspace_const_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDWorkspace_const_sptr> is required.
template<>
MANTID_API_DLL Mantid::API::IMDWorkspace_sptr	IPropertyManager::getValue< Mantid::API::IMDWorkspace_sptr > (const std::string &name) const
	In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.
template<>
DLLExport Mantid::DataObjects::EventWorkspace_const_sptr	IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_const_sptr > (const std::string &name) const
template<>
DLLExport Mantid::DataObjects::EventWorkspace_sptr	IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_sptr > (const std::string &name) const
template<>
DLLExport Mantid::DataObjects::Workspace2D_const_sptr	IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_const_sptr > (const std::string &name) const
template<>
DLLExport Mantid::DataObjects::Workspace2D_sptr	IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_sptr > (const std::string &name) const
template<>
DLLExport Mantid::DataObjects::WorkspaceSingleValue_const_sptr	IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_const_sptr > (const std::string &name) const
template<>
DLLExport Mantid::DataObjects::WorkspaceSingleValue_sptr	IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_sptr > (const std::string &name) const
bool	isFilter (const SplittingIntervalVec &a)
	Return true if the SplittingIntervalVec provided is a filter, meaning that it only has an output index of 0.
template<typename T >
MANTID_KERNEL_DLL bool	ltEquals (T const x, T const y)
	Test whether x<=y within machine precision.
template<class T , class... Args>
cow_ptr< T >	make_cow (Args &&...args)
template<typename T >
CatalogConfigService *	makeCatalogConfigServiceAdapter (const T &adaptee, const std::string &key="icatDownload.mountPoint")
MDUnitFactory_uptr MANTID_KERNEL_DLL	makeMDUnitFactoryChain ()
	Convience method. Pre-constructed builder chain.
template<typename TYPE >
std::string	memToString (const TYPE mem_in_kiB)
	Convert a (number) for memory in kiB to a string with proper units.
template<typename TYPE >
string	memToString (const TYPE mem_in_kiB)
	Utility function to convert memory in kiB into easy to read units.
template DLLExport string	memToString< uint32_t > (const uint32_t)
template DLLExport string	memToString< uint64_t > (const uint64_t)
MANTID_KERNEL_DLL V3D	normalize (V3D v)
	Normalizes a V3D.
MANTID_KERNEL_DLL bool	operator!= (const Mantid::Kernel::Property &lhs, const Mantid::Kernel::Property &rhs)
	Compares this to another property for inequality.
MANTID_KERNEL_DLL SplittingIntervalVec	operator& (const SplittingIntervalVec &a, const SplittingIntervalVec &b)
	AND operator for SplittingIntervalVec Works on Filters - combines them to only keep times where both Filters are TRUE.
MANTID_KERNEL_DLL SplittingIntervalVec	operator+ (const SplittingIntervalVec &a, const SplittingIntervalVec &b)
	Plus operator for SplittingIntervalVec.
template<class _CharT , class _Traits , class _RT >
std::basic_ostream< _CharT, _Traits > &	operator<< (std::basic_ostream< _CharT, _Traits > &__os, const normal_distribution< _RT > &__x)
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &, const VMDBase< float > &)
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &buffer, const InstrumentInfo &instrumentDescriptor)
	Allow this object to be printed to a stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &buffer, const LiveListenerInfo &listener)
	Allow this object to be printed to a stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &buffer, const TopicInfo &topic)
	Allow this object to be printed to a stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const EnvironmentHistory &EH)
	Prints a text representation.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const Interpolation &f)
	Prints the value of parameter.
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Matrix< T > &matrix)
	Write an object to a stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const PropertyHistory &AP)
	Prints a text representation.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const Quat &q)
	Prints a string representation.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const V2D &point)
	Output stream operator.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const V3D &v)
	Prints a text representation of itself.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, const VMDBase< double > &v)
	Prints a text representation of itself.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &os, OptionalBool const &object)
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &out, const CodeBlockMultipleTimer::TimeAccumulator &ta)
	Output timing summary to a stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &out, const MemoryStats &stats)
	Convenience function for writting out to stream.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &out, const Timer &obj)
	Convenience function to provide for easier debug printing.
MANTID_KERNEL_DLL std::ostream &	operator<< (std::ostream &out, CPUTimer &obj)
	Convenience function to provide for easier debug printing.
std::ostream &	operator<< (std::ostream &s, const Mantid::Kernel::TimeInterval &t)
MANTID_KERNEL_DLL bool	operator== (const Mantid::Kernel::Property &lhs, const Mantid::Kernel::Property &rhs)
	Compares this to another property for equality.
template<class _CharT , class _Traits , class _RT >
std::basic_istream< _CharT, _Traits > &	operator>> (std::basic_istream< _CharT, _Traits > &__is, normal_distribution< _RT > &__x)
MANTID_KERNEL_DLL std::istream &	operator>> (std::istream &in, Interpolation &f)
	Reads in parameter value.
MANTID_KERNEL_DLL std::istream &	operator>> (std::istream &ins, Quat &q)
	Reads in a quat from an input stream.
template<typename T >
std::istream &	operator>> (std::istream &is, Kernel::Matrix< T > &in)
	Fill an object from a stream.
MANTID_KERNEL_DLL std::istream &	operator>> (std::istream &istream, OptionalBool &object)
MANTID_KERNEL_DLL std::istream &	operator>> (std::istream &IX, V3D &A)
	Calls Vec3D method write to output class.
MANTID_KERNEL_DLL SplittingIntervalVec	operator| (const SplittingIntervalVec &a, const SplittingIntervalVec &b)
	OR operator for SplittingIntervalVec Only works on Filters, not splitters.
MANTID_KERNEL_DLL SplittingIntervalVec	operator~ (const SplittingIntervalVec &a)
	NOT operator for SplittingIntervalVec Only works on Filters.
template<typename T >
std::pair< T, T >	parallel_minmax (std::shared_ptr< std::vector< T > > const &vec, size_t const grainsize=1000)
	parallel_minmax
template<typename T >
std::pair< T, T >	parallel_minmax (std::unique_ptr< std::vector< T > > const &vec, size_t const grainsize=1000)
	parallel_minmax
template<typename T >
std::pair< T, T >	parallel_minmax (std::vector< T > const *const vec, size_t const grainsize=1000)
	parallel_minmax
void	process_mem_usage (size_t &vm_usage, size_t &resident_set)
	Attempts to read the system-dependent data for a process' virtual memory size and resident set size, and return the results in KB.
template<typename T >
MANTID_KERNEL_DLL T	relativeDifference (T const x, T const y)
	Calculate relative difference between x, y.
template<typename T >
T	relativeDifference (T const x, T const y)
	Calculate the relative difference of two floating-point numbers.
SplittingIntervalVec	removeFilterOverlap (const SplittingIntervalVec &a)
	Remove any overlap in a filter (will not work properly on a splitter)
void	swap (MultiFileValidator &obj1, MultiFileValidator &obj2)
template<typename Arg >
std::enable_if< std::is_pointer< Arg >::value, bool >::type	threadSafe (Arg workspace)
	Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.
template<typename Arg , typename... Args>
std::enable_if< std::is_pointer< Arg >::value, bool >::type	threadSafe (Arg workspace, Args &&...others)
	Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.
template<typename Arg >
std::enable_if<!std::is_pointer< Arg >::value, bool >::type	threadSafe (const Arg &workspace)
	Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.
template<typename Arg , typename... Args>
std::enable_if<!std::is_pointer< Arg >::value, bool >::type	threadSafe (const Arg &workspace, Args &&...others)
	Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.
MANTID_KERNEL_DLL double	timeMean (const Kernel::Property *p, const TimeROI *roi=nullptr)
	Returns the mean value if the property is TimeSeriesProperty<double>
MANTID_KERNEL_DLL std::map< int, TimeROI >	timeROIsFromSplitters (const SplittingIntervalVec &splitters)
	For every workspace index, create a TimeROI out of its associated splitting intervals.
template<typename T >
std::string	toPrettyString (const std::shared_ptr< T > &value, size_t maxLength=0, bool collapseLists=true)
	Throw an exception if a shared pointer is converted to a pretty string.
template<>
std::string	toPrettyString (const std::vector< bool > &value, size_t maxLength, bool collapseLists, const std::string &delimiter, const std::string &unusedDelimiter, typename std::enable_if< std::is_same< bool, bool >::value >::type *)
	Explicit specialization for a property of type std::vector<bool>.
template<typename T >
std::string	toPrettyString (const std::vector< std::vector< T > > &value, size_t maxLength=0, bool collapseLists=true, const std::string &outerDelimiter=",", const std::string &innerDelimiter="+")
	Specialization for a property of type std::vector<std::vector>.
template<typename T >
std::string	toPrettyString (const std::vector< T > &value, size_t maxLength=0, bool collapseLists=true, const std::string &delimiter=",", const std::string &listDelimiter="-", typename std::enable_if< std::is_integral< T >::value &&std::is_arithmetic< T >::value >::type *=nullptr)
	Specialization for a property of type std::vector of integral types.
template<typename T >
std::string	toPrettyString (const std::vector< T > &value, size_t maxLength=0, bool collapseLists=true, const std::string &delimiter=",", const std::string &unusedDelimiter="+", typename std::enable_if<!(std::is_integral< T >::value &&std::is_arithmetic< T >::value)>::type *=nullptr)
	Specialization for a property of type std::vector of non integral types.
template<typename T >
std::string	toPrettyString (const T &value, size_t maxLength=0, bool collapseLists=true)
	Convert values to pretty strings.
template<>
std::string	toPrettyString (PythonObject const &value, size_t, bool)
	Creates a pretty string representation of the object.
Kernel::Quat	toQuat (const Eigen::Quaterniond &quat)
	Converts Eigen::Quaterniond to Kernel::Quat.
Eigen::Quaterniond	toQuaterniond (const Kernel::Quat &quat)
	Converts Kernel::Quat to Eigen::Quaterniond.
template<typename T >
std::string	toString (const std::shared_ptr< T > &)
	Throw an exception if a shared pointer is converted to a string.
template<typename T >
std::string	toString (const std::vector< std::vector< T > > &value, const std::string &outerDelimiter=",", const std::string &innerDelimiter="+")
	Specialization for a property of type std::vector<std::vector>.
template<typename T >
std::string	toString (const std::vector< T > &value, const std::string &delimiter=",")
	Specialization for a property of type std::vector.
template<typename T >
std::string	toString (const T &value)
	Convert values to strings.
template<>
std::string	toString (PythonObject const &obj)
	Creates a string representation of the object.
Kernel::V3D	toV3D (const Eigen::Vector3d &vec)
	This header provides conversion helpers between vector and rotation types in MantidKernel and equivalent types in Eigen.
template<typename T >
void	toValue (const std::string &, std::shared_ptr< T > &)
template<>
MANTID_KERNEL_DLL void	toValue (const std::string &strValue, OptionalBool &value)
	Helper functions for setting the value of an OptionalBool property.
template<>
void MANTID_KERNEL_DLL	toValue (const std::string &strValue, OptionalBool &value)
	Helper functions for setting the value of an OptionalBool property.
template<typename T >
void	toValue (const std::string &strvalue, std::vector< std::vector< T > > &value, const std::string &outerDelimiter=",", const std::string &innerDelimiter="+")
template<typename T >
void	toValue (const std::string &strvalue, std::vector< T > &value)
template<typename T >
void	toValue (const std::string &strvalue, T &value)
Eigen::Vector3d	toVector3d (const Kernel::V3D &vec)
	Converts Kernel::V3D to Eigen::Vector3d.
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinAbsoluteDifference (T const x, T const y, S const tolerance)
	Test whether x, y are within absolute tolerance tol.
template<typename T , typename S >
bool	withinAbsoluteDifference (T const x, T const y, S const tolerance)
	Compare floating point numbers for absolute difference to within the given tolerance.
template<typename T , typename S >
bool	withinAbsoluteDifference (T const x, T const y, S const tolerance, MADE_FOR_FLOATS)
	Compare floating point numbers for absolute difference to within the given tolerance.
template<typename T , typename S >
bool	withinAbsoluteDifference (T const x, T const y, S const tolerance, MADE_FOR_INTEGERS)
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinAbsoluteDifference (T const x, T const y, S const tolerance, std::false_type)
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinAbsoluteDifference (T const x, T const y, S const tolerance, std::true_type)
template<>
DLLExport bool	withinAbsoluteDifference< V3D, double > (V3D const V1, V3D const V2, double const tolerance)
	Template specialization for V3D.
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinRelativeDifference (T const x, T const y, S const tolerance)
	Test whether x, y are within relative tolerance tol.
template<typename T , typename S >
bool	withinRelativeDifference (T const x, T const y, S const tolerance)
	Compare floating point numbers for relative difference to within the given tolerance.
template<typename T , typename S >
bool	withinRelativeDifference (T const x, T const y, S const tolerance, MADE_FOR_FLOATS)
	Compare floating point numbers for relative difference to within the given tolerance.
template<typename T , typename S >
bool	withinRelativeDifference (T const x, T const y, S const tolerance, MADE_FOR_INTEGERS)
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinRelativeDifference (T const x, T const y, S const tolerance, std::false_type)
template<typename T , typename S = T>
MANTID_KERNEL_DLL bool	withinRelativeDifference (T const x, T const y, S const tolerance, std::true_type)
template<>
DLLExport bool	withinRelativeDifference< V3D, double > (V3D const V1, V3D const V2, double const tolerance)
	Compare 3D vectors (class V3D) for relative difference to within the given tolerance.

Variables
EXTERN_MANTID_KERNEL template class MANTID_KERNEL_DLL	CubicSpline< double, double >
constexpr size_t	DEFAULT_BLOCK_SIZE {100000}
	Default number of items to read in from any of the files.
Kernel::Logger	g_log ("UsageServiceImpl")
	static logger
const std::string	LIB_PREFIX = "lib"
EXTERN_MANTID_KERNEL template class MANTID_KERNEL_DLL	LinearSpline< double, double >
constexpr size_t	MAX_BLOCK_SIZE {100000000}
	Max size block to read from a file (memory limitations)
constexpr size_t	MIN_BLOCK_SIZE {1000}
	Min size of a block (too small is inefficient)
template class MANTID_PYTHONINTERFACE_CORE_DLL	PropertyWithValue< PythonObject >
	NOTE: For Linux builds (and maybe Windows), it is necessary that the below DLL export occur here.
constexpr double	Tolerance = 1.0e-06
	Standard tolerance value.

Typedef Documentation

CaseInsensitiveMap

template<class T >

using Mantid::Kernel::CaseInsensitiveMap = typedef std::map<std::string, T, CaseInsensitiveStringComparator>

Alias template for a map data structure that has case insensitive string comparision with a variable value type.

Definition at line 30 of file CaseInsensitiveMap.h.

CaseSensitiveStringComparator

using Mantid::Kernel::CaseSensitiveStringComparator = typedef std::less<std::string>

Definition at line 36 of file DynamicFactory.h.

ConfigService

using Mantid::Kernel::ConfigService = typedef Mantid::Kernel::SingletonHolder<ConfigServiceImpl>

Definition at line 302 of file ConfigService.h.

ConfigValChangeNotification

using Mantid::Kernel::ConfigValChangeNotification = typedef Mantid::Kernel::ConfigServiceImpl::ValueChanged

Definition at line 304 of file ConfigService.h.

ConfigValChangeNotification_ptr

using Mantid::Kernel::ConfigValChangeNotification_ptr = typedef const Poco::AutoPtr<Mantid::Kernel::ConfigServiceImpl::ValueChanged> &

Definition at line 305 of file ConfigService.h.

DataItem_const_sptr

using Mantid::Kernel::DataItem_const_sptr = typedef std::shared_ptr<const DataItem>

Shared pointer to a const DataItem.

Definition at line 86 of file DataItem.h.

DataItem_sptr

using Mantid::Kernel::DataItem_sptr = typedef std::shared_ptr<DataItem>

Shared pointer to a DataItem.

Definition at line 84 of file DataItem.h.

DataXY

using Mantid::Kernel::DataXY = typedef std::pair<double, double>

Definition at line 22 of file Interpolation.h.

DateAndTimeIter

using Mantid::Kernel::DateAndTimeIter = typedef std::vector<DateAndTime>::iterator

Definition at line 20 of file TimeROI.cpp.

DblMatrix

using Mantid::Kernel::DblMatrix = typedef Mantid::Kernel::Matrix<double>

Definition at line 206 of file Matrix.h.

FloatMatrix

using Mantid::Kernel::FloatMatrix = typedef Mantid::Kernel::Matrix<float>

Definition at line 208 of file Matrix.h.

IntMatrix

using Mantid::Kernel::IntMatrix = typedef Mantid::Kernel::Matrix<int>

Definition at line 207 of file Matrix.h.

IValidator_sptr

using Mantid::Kernel::IValidator_sptr = typedef std::shared_ptr<IValidator>

A shared_ptr to an IValidator.

Definition at line 26 of file IValidator.h.

LibraryManager

using Mantid::Kernel::LibraryManager = typedef Mantid::Kernel::SingletonHolder<LibraryManagerImpl>

Definition at line 63 of file LibraryManager.h.

Material_const_sptr

using Mantid::Kernel::Material_const_sptr = typedef std::shared_ptr<const Material>

Typedef for a shared pointer to a const object.

Definition at line 206 of file Material.h.

Material_sptr

using Mantid::Kernel::Material_sptr = typedef std::shared_ptr<Material>

Typedef for a shared pointer.

Definition at line 204 of file Material.h.

MDUnit_const_uptr

using Mantid::Kernel::MDUnit_const_uptr = typedef std::unique_ptr<const MDUnit>

Definition at line 71 of file MDUnit.h.

MDUnit_uptr

using Mantid::Kernel::MDUnit_uptr = typedef std::unique_ptr<MDUnit>

Definition at line 70 of file MDUnit.h.

MDUnitFactory_const_uptr

using Mantid::Kernel::MDUnitFactory_const_uptr = typedef std::unique_ptr<const MDUnitFactory>

Definition at line 51 of file MDUnitFactory.h.

MDUnitFactory_uptr

using Mantid::Kernel::MDUnitFactory_uptr = typedef std::unique_ptr<MDUnitFactory>

Definition at line 49 of file MDUnitFactory.h.

OptionalPath

using Mantid::Kernel::OptionalPath = typedef std::optional<std::string>

Definition at line 17 of file UserCatalogInfo.h.

PropertyHistories

using Mantid::Kernel::PropertyHistories = typedef std::vector<PropertyHistory_sptr>

Definition at line 86 of file PropertyHistory.h.

PropertyHistory_const_sptr

using Mantid::Kernel::PropertyHistory_const_sptr = typedef std::shared_ptr<const PropertyHistory>

Definition at line 85 of file PropertyHistory.h.

PropertyHistory_sptr

using Mantid::Kernel::PropertyHistory_sptr = typedef std::shared_ptr<PropertyHistory>

Definition at line 84 of file PropertyHistory.h.

PropertyManager_const_sptr

using Mantid::Kernel::PropertyManager_const_sptr = typedef std::shared_ptr<const PropertyManager>

shared pointer to Mantid::Kernel::PropertyManager(const version)

Definition at line 22 of file PropertyManager_fwd.h.

PropertyManager_const_uptr

using Mantid::Kernel::PropertyManager_const_uptr = typedef std::unique_ptr<const PropertyManager>

unique pointer to Mantid::Kernel::PropertyManager (const version)

Definition at line 26 of file PropertyManager_fwd.h.

PropertyManager_sptr

typedef std::shared_ptr< PropertyManager > Mantid::Kernel::PropertyManager_sptr

Typedef for a shared pointer to a PropertyManager.

shared pointer to Mantid::Kernel::PropertyManager

Definition at line 23 of file PDDetermineCharacterizations.h.

PropertyManager_uptr

using Mantid::Kernel::PropertyManager_uptr = typedef std::unique_ptr<PropertyManager>

unique pointer to Mantid::Kernel::PropertyManager

Definition at line 24 of file PropertyManager_fwd.h.

PropertyManagerDataService

using Mantid::Kernel::PropertyManagerDataService = typedef Mantid::Kernel::SingletonHolder<PropertyManagerDataServiceImpl>

Definition at line 36 of file PropertyManagerDataService.h.

PythonObject

using Mantid::Kernel::PythonObject = typedef boost::python::object

Definition at line 26 of file PythonObjectProperty.h.

SingletonDeleterFn

using Mantid::Kernel::SingletonDeleterFn = typedef std::function<void()>

Type of deleter function.

Definition at line 34 of file SingletonHolder.h.

SplittingIntervalVec

typedef std::vector< SplittingInterval > Mantid::Kernel::SplittingIntervalVec

A typedef for splitting events according their pulse time.

It is a vector of SplittingInterval classes.

Definition at line 28 of file LogManager.h.

str_pair

using Mantid::Kernel::str_pair = typedef std::pair<std::string, std::string>

Definition at line 19 of file Material.cpp.

StringListValidator

using Mantid::Kernel::StringListValidator = typedef ListValidator<std::string>

ListValidator<std::string> is used heavily.

Definition at line 168 of file ListValidator.h.

time_point_ns

typedef std::chrono::time_point< std::chrono::high_resolution_clock > Mantid::Kernel::time_point_ns

Definition at line 39 of file Algorithm.h.

tokenizer

using Mantid::Kernel::tokenizer = typedef Mantid::Kernel::StringTokenizer

Definition at line 18 of file Material.cpp.

Unit_const_sptr

using Mantid::Kernel::Unit_const_sptr = typedef std::shared_ptr<const Unit>

Shared pointer to the Unit base class (const version)

Definition at line 196 of file Unit.h.

Unit_sptr

using Mantid::Kernel::Unit_sptr = typedef std::shared_ptr<Unit>

Shared pointer to the Unit base class.

Definition at line 194 of file Unit.h.

UnitFactory

using Mantid::Kernel::UnitFactory = typedef SingletonHolder<UnitFactoryImpl>

Definition at line 79 of file UnitFactory.h.

UnitParametersMap

using Mantid::Kernel::UnitParametersMap = typedef std::unordered_map<UnitParams, double>

Definition at line 30 of file Unit.h.

UsageService

using Mantid::Kernel::UsageService = typedef Mantid::Kernel::SingletonHolder<UsageServiceImpl>

Definition at line 153 of file UsageService.h.

VMD

using Mantid::Kernel::VMD = typedef VMDBase<VMD_t>

Define the VMD as using the double or float data type.

Definition at line 86 of file VMD.h.

VMD_t

using Mantid::Kernel::VMD_t = typedef float

Underlying data type for the VMD type.

Definition at line 83 of file VMD.h.

Enumeration Type Documentation

CompositeRelation

enum class Mantid::Kernel::CompositeRelation

strong

A composite validator that can combine any 2+ arbitrary validators together.

Author

Russell Taylor, Janik Zikovsky

Date

Aug 25, 2011

Enumerator
AND
OR

Definition at line 28 of file CompositeValidator.h.

DataServiceHidden

enum class Mantid::Kernel::DataServiceHidden

strong

Flag for whether to include hidden items when returning, Auto queries the class to determine this behavior.

Enumerator
Auto
Include
Exclude

Definition at line 37 of file DataService.h.

DataServiceSort

enum class Mantid::Kernel::DataServiceSort

strong

Flag for whether to sort items before returning.

Enumerator
Sorted
Unsorted

Definition at line 32 of file DataService.h.

eLogicOperator

enum Mantid::Kernel::eLogicOperator

Enum for use when combining two EnabledWhenPropertyItems.

Enumerator
AND
OR
XOR

Definition at line 60 of file EnabledWhenProperty.h.

ePropertyCriterion

enum Mantid::Kernel::ePropertyCriterion

Enum for use in EnabledWhenProperty.

Enumerator
IS_DEFAULT
IS_NOT_DEFAULT
IS_EQUAL_TO
IS_NOT_EQUAL_TO
IS_MORE_OR_EQ

Definition at line 57 of file EnabledWhenProperty.h.

FeatureType

enum class Mantid::Kernel::FeatureType

strong

An enum specifying the 4 possible features types that can be logged in the usage service.

Enumerator
Algorithm
Interface
Feature
Function

Definition at line 28 of file UsageService.h.

MemoryStatsIgnore

enum Mantid::Kernel::MemoryStatsIgnore

Enmuerate the ignored memory fields.

Enumerator
MEMORY_STATS_IGNORE_NONE
MEMORY_STATS_IGNORE_SYSTEM
MEMORY_STATS_IGNORE_PROCESS

Definition at line 19 of file Memory.h.

SpecialCoordinateSystem

enum Mantid::Kernel::SpecialCoordinateSystem

Special coordinate systems for Q3D.

Enumerator
None
QLab
QSample
HKL

Definition at line 14 of file SpecialCoordinateSystem.h.

TimeSeriesSortStatus

enum Mantid::Kernel::TimeSeriesSortStatus

Enumerator
TSUNKNOWN
TSUNSORTED
TSSORTED

Definition at line 26 of file TimeSeriesProperty.h.

TopicType

enum class Mantid::Kernel::TopicType

strong

Enumerator
Event
Chopper
Sample
Run
Monitor

Definition at line 29 of file TopicInfo.h.

UnitParams

enum class Mantid::Kernel::UnitParams

strong

Enumerator
l2
twoTheta
efixed
delta
difa
difc
tzero

Definition at line 26 of file Unit.h.

Function Documentation

absoluteDifference() [1/2]

template<typename T >

MANTID_KERNEL_DLL T Mantid::Kernel::absoluteDifference	(	T const	x,
		T const	y
	)

Calculate absolute difference between x, y.

Calculate absolute difference between x, y.

Calculate the absolute difference of two floating-point numbers

Parameters

x	:: first value
y	:: second value

Returns

the value of the absolute difference

Definition at line 101 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

absoluteDifference() [2/2]

template<typename T >

T Mantid::Kernel::absoluteDifference	(	T const	x,
		T const	y
	)

ABSOLUTE AND RELATIVE DIFFERENCE.

Calculate absolute difference between x, y.

Calculate the absolute difference of two floating-point numbers

Parameters

x	:: first value
y	:: second value

Returns

the value of the absolute difference

Definition at line 101 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

addingOperator() [1/5]

template<>

void Mantid::Kernel::addingOperator ( bool &  , const bool &    )

inline

Definition at line 306 of file PropertyHelper.h.

addingOperator() [2/5]

template<>

void Mantid::Kernel::addingOperator ( OptionalBool &  , const OptionalBool &    )

inline

Definition at line 310 of file PropertyHelper.h.

addingOperator() [3/5]

template<typename T >

void Mantid::Kernel::addingOperator ( std::shared_ptr< T > &  , const std::shared_ptr< T > &    )

inline

Definition at line 314 of file PropertyHelper.h.

addingOperator() [4/5]

template<typename T >

void Mantid::Kernel::addingOperator ( std::vector< T > &  lhs, const std::vector< T > &  rhs  )

inline

Definition at line 296 of file PropertyHelper.h.

References rhs.

addingOperator() [5/5]

template<typename T >

void Mantid::Kernel::addingOperator ( T &  lhs, const T &  rhs  )

inline

Definition at line 287 of file PropertyHelper.h.

References rhs.

Referenced by Mantid::Kernel::PropertyWithValue< TYPE >::operator+=().

appendValue()

template<typename T >

void Mantid::Kernel::appendValue ( const std::string &  strvalue, std::vector< T > &  value  )

inline

Definition at line 145 of file PropertyHelper.h.

References value.

Referenced by Mantid::Kernel::detail::toValue().

AtomicOp()

template<typename T , typename BinaryOp >

void Mantid::Kernel::AtomicOp	(	std::atomic< T > &	f,
		T	d,
		BinaryOp	op
	)

Uses std::compare_exchange_weak to update the atomic value f = op(f, d) Used to improve parallel scaling in algorithms MDNormDirectSC and MDNormSCD.

Parameters

f	atomic variable being updated
d	second element in binary operation
op	binary operation on elements f and d

Definition at line 67 of file MultiThreaded.h.

References Mantid::Geometry::d.

Referenced by Mantid::MDAlgorithms::MDNorm::calcSingleDetectorNorm(), Mantid::MDAlgorithms::MDNormDirectSC::calculateNormalization(), and Mantid::MDAlgorithms::MDNormSCD::calculateNormalization().

canRead()

bool Mantid::Kernel::canRead

(

const std::string &

filename

)

Returns

true if the file exists and can be read

Definition at line 1075 of file ConfigService.cpp.

Referenced by Mantid::Kernel::ConfigServiceImpl::getOSVersionReadable().

compareTasks()

bool Mantid::Kernel::compareTasks	(	Task *	lhs,
		Task *	rhs
	)

Method to perform sorting of task lists.

This prioritizes long tasks, so they end up at start of the list.

Parameters

lhs	:: Task*
rhs	:: Task*

Returns

true if lhs < rhs (aka lhs should be first)

Definition at line 140 of file ThreadPool.cpp.

References Mantid::Kernel::Task::cost(), and rhs.

createPropertyManager()

PropertyManager_sptr Mantid::Kernel::createPropertyManager

(

const Json::Value &

keyValues

)

Attempt to create a PropertyManager from the Json::Value.

Create a PropertyManager from a Json Object.

Parameters

keyValues

A Json objectValue. This is not checked.

Returns

A new PropertyManager

Exceptions

std::invalid_argument

if the Json::Value can't be interpreted

Definition at line 130 of file PropertyWithValueJSON.cpp.

References createPropertyManager(), and value.

Referenced by Mantid::PythonInterface::Registry::MappingTypeHandler::create(), Mantid::PythonInterface::Registry::createPropertyManager(), createPropertyManager(), Mantid::PythonInterface::Registry::MappingTypeHandler::set(), and Mantid::Kernel::PropertyManagerProperty::setValueFromJson().

decode()

template<typename Type >

Type Mantid::Kernel::decode

(

const Json::Value &

value

)

Attempt to decode the given Json::Value as the given Type.

Definition at line 91 of file PropertyWithValueJSON.h.

References value.

decodeAsProperty()

std::unique_ptr< Property > Mantid::Kernel::decodeAsProperty	(	const std::string &	name,
		const Json::Value &	value
	)

Attempt to create a Property of the most appropriate type from a string name and Json value object.

Parameters

name	The name of the new property
value	A value as a Json serialized quantity

Returns

A pointer to a new Property if the underlying value can be converted to a known C++ type

Exceptions

std::invalid_argument

If the value cannot be transformed to a Property object

Definition at line 151 of file PropertyWithValueJSON.cpp.

References name, and value.

Referenced by Mantid::Kernel::PropertyManager::setProperties().

deleteOnExit()

void Mantid::Kernel::deleteOnExit

(

const SingletonDeleterFn &

func

)

Register the given deleter function to be called at exit.

Adds singleton cleanup function to our atexit list functions are added to the start of the list so on deletion it is last in, first out.

Parameters

func	:: Exit function to call - the singleton destructor function

Definition at line 38 of file SingletonHolder.cpp.

Referenced by Mantid::Kernel::SingletonHolder< T >::Instance().

determineAllowedValues() [1/2]

template<>

std::vector< std::string > Mantid::Kernel::determineAllowedValues ( const OptionalBool &  , const IValidator &    )

inline

Definition at line 322 of file PropertyHelper.h.

References Mantid::Kernel::OptionalBool::enumToStrMap().

determineAllowedValues() [2/2]

template<typename T >

std::vector< std::string > Mantid::Kernel::determineAllowedValues ( const T &  , const IValidator &  validator  )

inline

Definition at line 318 of file PropertyHelper.h.

References Mantid::Kernel::IValidator::allowedValues().

Referenced by Mantid::Kernel::PropertyWithValue< TYPE >::allowedValues().

dumpToStream()

template<typename T >

void Mantid::Kernel::dumpToStream	(	std::ostream &	os,
		const Kernel::Matrix< T > &	matrix,
		const char	delimiter
	)

Write a Matrix to a stream.

Format will be Matrix(nrowsSEPncols)x_00SEPx_01...SEPx_10SEPx_11

Parameters

os	:: output stream
matrix	:: Matrix to write out
delimiter	:: A character to use as delimiter for the string

Definition at line 1596 of file Matrix.cpp.

References ncols, nrows, Mantid::Kernel::Matrix< T >::numCols(), and Mantid::Kernel::Matrix< T >::numRows().

Referenced by operator<<().

encodeAsJson() [1/8]

template<typename ValueType >

Json::Value Mantid::Kernel::encodeAsJson

(

const Kernel::Matrix< ValueType > &

)

Encode a Matrix as a Json::Value.

Currently throws as it is not required

Returns

A new Json::Value

Exceptions

Exception::NotImplementedError

Definition at line 180 of file PropertyWithValueJSON.h.

encodeAsJson() [2/8]

Json::Value Mantid::Kernel::encodeAsJson

(

const OptionalBool &

value

)

Encode an OptionalBool as a Json::Value.

Throws as it's not clear how to serialize this type.

Returns

A new Json::Value

Definition at line 98 of file OptionalBool.cpp.

References Mantid::Kernel::OptionalBool::False, Mantid::Kernel::OptionalBool::True, and value.

Referenced by encodeAsJson(), encodeAsJson(), Mantid::Kernel::EnumeratedStringProperty< E, names >::valueAsJson(), and Mantid::Kernel::PropertyWithValue< TYPE >::valueAsJson().

encodeAsJson() [3/8]

Json::Value Mantid::Kernel::encodeAsJson

(

const PropertyManager &

propMgr

)

Return the value of the PropertyManager as a Json::Value.

Creates a Json::Value of type objectValue to store the properties.

Parameters

propMgr

A reference to a

Returns

A new Json::Value of type objectValue

Definition at line 731 of file PropertyManager.cpp.

References Mantid::Kernel::PropertyManager::asJson().

encodeAsJson() [4/8]

template<typename ValueType >

Json::Value Mantid::Kernel::encodeAsJson

(

const std::shared_ptr< ValueType > &

)

Encode a shared_ptr by dereferencing a it and encoding its value.

Returns

A new Json::Value

Exceptions

std::runtime_error

for all inputs

Definition at line 171 of file PropertyWithValueJSON.h.

encodeAsJson() [5/8]

template<>

Json::Value Mantid::Kernel::encodeAsJson ( const std::vector< bool > &  vectorValue )

inline

Specialization to encode a std::vector<bool> value as a Json::Value arrayValue type.

Needs to deal with the fact that the return value from an iterator is a temporary object

Parameters

vectorValue

The C++ value to encode

Returns

A new Json::Value

Definition at line 158 of file PropertyWithValueJSON.h.

References encodeAsJson().

encodeAsJson() [6/8]

template<typename ValueType >

Json::Value Mantid::Kernel::encodeAsJson

(

const std::vector< ValueType > &

vectorValue

)

Encode a std::vector value as a Json::Value arrayValue type.

Parameters

vectorValue

The C++ value to encode

Returns

A new Json::Value

Definition at line 144 of file PropertyWithValueJSON.h.

References encodeAsJson().

encodeAsJson() [7/8]

template<typename ValueType >

Json::Value Mantid::Kernel::encodeAsJson

(

const ValueType &

value

)

Encode a single value as a Json::Value.

Parameters

value

The C++ value to encode

Returns

A new Json::Value

Definition at line 134 of file PropertyWithValueJSON.h.

References value.

encodeAsJson() [8/8]

template<>

Json::Value Mantid::Kernel::encodeAsJson

(

PythonObject const &

)

Creates a Json representation of the object.

Definition at line 132 of file PythonObjectProperty.cpp.

equals() [1/6]

template<typename T >

MANTID_KERNEL_DLL bool Mantid::Kernel::equals	(	T const	x,
		T const	y
	)

Test for equality of doubles using compiler-defined precision.

Test for equality of doubles using compiler-defined precision.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered equal within machine precision. Machine precision is a 1 at the least significant bit scaled to the same power as the numbers compared. E.g. for 1, it is usually 1x2^{-52} E.g. for 1x2^100, it is usually 1x2^{-52} x 1x2^100 = 1x2^{48} False if any value is NaN. False if comparing opposite infinities.

Definition at line 33 of file FloatingPointComparison.cpp.

References equals(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by equals(), Mantid::Algorithms::CalculateCarpenterSampleCorrection::exec(), Mantid::Algorithms::FindCenterOfMassPosition2::findCenterOfMass(), gtEquals(), ltEquals(), and Mantid::Kernel::Matrix< T >::operator==().

equals() [2/6]

template<typename T >

bool Mantid::Kernel::equals	(	T const	x,
		T const	y
	)

Compare numbers for equality to within machine epsilon.

Test for equality of doubles using compiler-defined precision.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered equal within machine precision. Machine precision is a 1 at the least significant bit scaled to the same power as the numbers compared. E.g. for 1, it is usually 1x2^{-52} E.g. for 1x2^100, it is usually 1x2^{-52} x 1x2^100 = 1x2^{48} False if any value is NaN. False if comparing opposite infinities.

Definition at line 33 of file FloatingPointComparison.cpp.

References equals(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by equals(), Mantid::Algorithms::CalculateCarpenterSampleCorrection::exec(), Mantid::Algorithms::FindCenterOfMassPosition2::findCenterOfMass(), gtEquals(), ltEquals(), and Mantid::Kernel::Matrix< T >::operator==().

equals() [3/6]

template<typename T >

bool Mantid::Kernel::equals ( T const  x, T const  y, MADE_FOR_FLOATS    )

inline

Compare floating point numbers for equality to within std::numeric_limits<TYPE>::epsilon precision.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered equal within machine precision. Machine precision is a 1 at the least significant bit scaled to the same power as the numbers compared. E.g. for 1, it is usually 1x2^{-52} E.g. for 1x2^100, it is usually 1x2^{-52} x 1x2^100 = 1x2^{48} False if any value is NaN. False if comparing opposite infinities.

Definition at line 54 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

equals() [4/6]

template<typename T >

bool Mantid::Kernel::equals ( T const  x, T const  y, MADE_FOR_INTEGERS    )

inline

Compare integer numbers.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered equal

Definition at line 41 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

equals() [5/6]

template<typename T >

MANTID_KERNEL_DLL bool Mantid::Kernel::equals ( T const  x, T const  y, std::false_type    )

inline

equals() [6/6]

template<typename T >

MANTID_KERNEL_DLL bool Mantid::Kernel::equals ( T const  x, T const  y, std::true_type    )

inline

extractToValueVector()

template<typename T >

T Mantid::Kernel::extractToValueVector

(

const std::string &

strvalue

)

Definition at line 279 of file PropertyHelper.h.

References toValue().

fast_exp()

double Mantid::Kernel::fast_exp ( double  y )

inline

Definition at line 29 of file Fast_Exponential.h.

References Mantid::Geometry::d, EXP_A, EXP_C, n, and Mantid::Geometry::y.

Referenced by Mantid::Algorithms::AbsorptionCorrection::retrieveBaseProperties().

fillFromStream()

template<typename T >

void Mantid::Kernel::fillFromStream	(	std::istream &	is,
		Kernel::Matrix< T > &	in,
		const char	delimiter
	)

Fill a Matrix from a stream using the given separator.

Format should be Matrix(nrowsSEPncols)x_00SEPx_01...SEPx_10SEPx_11 where SEP is replaced by the given separator

Parameters

is	:: A stream object
in	:: An Matrix object to fill
delimiter	:: A single character separator that delimits the entries

Definition at line 1628 of file Matrix.cpp.

References Mantid::Kernel::Matrix< T >::m_rawData, ncols, nrows, Mantid::Kernel::Matrix< T >::setMem(), and value.

Referenced by operator>>(), and Mantid::CurveFitting::Functions::ComptonScatteringCountRate::parseIntensityConstraintMatrix().

findSize() [1/2]

template<typename T >

int Mantid::Kernel::findSize

(

const std::vector< T > &

value

)

Specialization for properties that are of type vector.

Definition at line 142 of file PropertyHelper.h.

References value.

findSize() [2/2]

template<typename T >

int Mantid::Kernel::findSize

(

const T &

)

Specialization for any type, should be appropriate for properties with a single value.

Definition at line 139 of file PropertyHelper.h.

Referenced by Mantid::Kernel::PropertyWithValue< TYPE >::size().

getMedian()

template<typename TYPE >

double Mantid::Kernel::getMedian

(

const vector< TYPE > &

data

)

There are enough special cases in determining the median where it useful to put it in a single function.

Definition at line 52 of file Statistics.cpp.

References left, and right.

Referenced by Mantid::Algorithms::RemovePromptPulse::getFrequency(), getModifiedZscore(), and getStatistics().

getModifiedZscore()

template<typename TYPE >

std::vector< double > Mantid::Kernel::getModifiedZscore

(

const std::vector< TYPE > &

data

)

Return the modified Z score values for a dataset.

There are enough special cases in determining the modified Z score where it useful to put it in a single function.

Definition at line 137 of file Statistics.cpp.

References fabs, getMedian(), and tmp.

getModifiedZscore< double >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< double >	(	const vector< double > &	,
		const bool
	)

getModifiedZscore< float >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< float >	(	const vector< float > &	,
		const bool
	)

getModifiedZscore< int >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< int >	(	const vector< int > &	,
		const bool
	)

getModifiedZscore< long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< long >	(	const vector< long > &	,
		const bool
	)

getModifiedZscore< long long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< long long >	(	const vector< long long > &	,
		const bool
	)

getModifiedZscore< unsigned int >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< unsigned int >	(	const vector< unsigned int > &	,
		const bool
	)

getModifiedZscore< unsigned long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< unsigned long >	(	const vector< unsigned long > &	,
		const bool
	)

getModifiedZscore< unsigned long long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getModifiedZscore< unsigned long long >	(	const vector< unsigned long long > &	,
		const bool
	)

getMomentsAboutMean()

template<typename TYPE >

std::vector< double > Mantid::Kernel::getMomentsAboutMean	(	const std::vector< TYPE > &	x,
		const std::vector< TYPE > &	y,
		const int	maxMoment
	)

Return the first n-moments of the supplied data.

This will calculate the first n-moments (inclusive) about the mean (1st moment).

For example if maxMoment=2 then this will return 3 values: 0th (total weight), 1st (mean), 2nd (deviation).

Parameters

x	The independent values
y	The dependent values
maxMoment	The number of moments to calculate

Returns

The first n-moments.

Definition at line 355 of file Statistics.cpp.

References getMomentsAboutOrigin(), Mantid::Geometry::x, and Mantid::Geometry::y.

getMomentsAboutOrigin()

template<typename TYPE >

std::vector< double > Mantid::Kernel::getMomentsAboutOrigin	(	const std::vector< TYPE > &	x,
		const std::vector< TYPE > &	y,
		const int	maxMoment
	)

Return the first n-moments of the supplied data.

This will calculate the first n-moments (inclusive) about the origin.

For example if maxMoment=2 then this will return 3 values: 0th (total weight), 1st (mean), 2nd (deviation).

Parameters

x	The independent values
y	The dependent values
maxMoment	The number of moments to calculate

Returns

The first n-moments.

Definition at line 297 of file Statistics.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by getMomentsAboutMean().

getRFactor()

Rfactor Mantid::Kernel::getRFactor	(	const std::vector< double > &	obsI,
		const std::vector< double > &	calI,
		const std::vector< double > &	obsE
	)

Return the R-factors (Rwp) of a diffraction pattern data.

Return the Rwp of a diffraction pattern data.

Parameters

obsI	:: array of observed intensity values
calI	:: array of calculated intensity values;
obsE	:: array of error of the observed data;

Returns

:: RFactor including Rp and Rwp

Definition at line 231 of file Statistics.cpp.

References fabs, Mantid::Kernel::Rfactor::Rp, Mantid::Kernel::Rfactor::Rwp, and sigma.

Referenced by Mantid::CurveFitting::Algorithms::LeBailFit::calculateDiffractionPattern(), and Mantid::CurveFitting::Algorithms::LeBailFit::exec().

getStatistics()

template<typename TYPE >

Statistics Mantid::Kernel::getStatistics	(	const vector< TYPE > &	data,
		const unsigned int	flags
	)

Return a statistics object for the given data set.

Determine the statistics for a vector of data.

If it is sorted then let the function know so it won't make a copy of the data for determining the median.

Parameters

data	Data points whose statistics are to be evaluated
flags	A set of flags to control the computation of the stats

Definition at line 169 of file Statistics.cpp.

References Mantid::Kernel::StatOptions::CorrectedStdDev, getMedian(), getStatistics(), Mantid::Kernel::Statistics::maximum, Mantid::Kernel::Statistics::mean, Mantid::Kernel::StatOptions::Mean, Mantid::Kernel::Statistics::median, Mantid::Kernel::StatOptions::Median, Mantid::Kernel::Statistics::minimum, Mantid::Kernel::Statistics::standard_deviation, Mantid::Kernel::StatOptions::UncorrectedStdDev, and value.

Referenced by Mantid::Kernel::TimeSeriesProperty< TYPE >::averageValueInFilter(), Mantid::Algorithms::DetectorDiagnostic::calculateMedian(), Mantid::Algorithms::MayersSampleCorrectionStrategy::calculateMS(), Mantid::Crystal::PeakStatisticsTools::PeaksStatistics::calculatePeaksStatistics(), Mantid::Algorithms::VesuvioL1ThetaResolution::exec(), Mantid::Crystal::SortHKL::exec(), Mantid::MDAlgorithms::IntegrateEllipsoidsV1::exec(), Mantid::Kernel::TimeSeriesProperty< TYPE >::extractStatistic(), Mantid::Algorithms::FindPeakBackground::findBackground(), Mantid::Kernel::TimeSeriesProperty< TYPE >::getStatistics(), getStatistics(), getWeightedZscore(), getZscore(), Mantid::Kernel::TimeSeriesProperty< TYPE >::mean(), Mantid::MDAlgorithms::IntegrateEllipsoidsV2::outputAxisProfiles(), and Mantid::Kernel::TimeSeriesProperty< TYPE >::timeAverageValue().

getStatistics< bool >()

template<>

DLLExport Statistics Mantid::Kernel::getStatistics< bool >	(	const vector< bool > &	data,
		const unsigned int	flags
	)

Getting statistics of a boolean array should just give a bunch of NaNs.

Definition at line 218 of file Statistics.cpp.

References UNUSED_ARG.

getStatistics< double >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< double >	(	const vector< double > &	,
		const bool
	)

getStatistics< float >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< float >	(	const vector< float > &	,
		const bool
	)

getStatistics< int >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< int >	(	const vector< int > &	,
		const bool
	)

getStatistics< long >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< long >	(	const vector< long > &	,
		const bool
	)

getStatistics< long long >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< long long >	(	const vector< long long > &	,
		const bool
	)

getStatistics< string >()

template<>

DLLExport Statistics Mantid::Kernel::getStatistics< string >	(	const vector< string > &	data,
		const unsigned int	flags
	)

Getting statistics of a string array should just give a bunch of NaNs.

Definition at line 211 of file Statistics.cpp.

References UNUSED_ARG.

getStatistics< unsigned int >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< unsigned int >	(	const vector< unsigned int > &	,
		const bool
	)

getStatistics< unsigned long >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< unsigned long >	(	const vector< unsigned long > &	,
		const bool
	)

getStatistics< unsigned long long >()

template MANTID_KERNEL_DLL Statistics Mantid::Kernel::getStatistics< unsigned long long >	(	const vector< unsigned long long > &	,
		const bool
	)

getUnmangledTypeName()

std::string Mantid::Kernel::getUnmangledTypeName

(

const std::type_info &

type

)

Return the name corresponding to the mangled string given by typeid.

Get the unmangled name of the given typestring for some common types that we use.

Note that this is just a lookup and NOT an unmangling algorithm

Parameters

type	:: A pointer to the type_info object for this type

Returns

An unmangled version of the name

Definition at line 285 of file Property.cpp.

References name.

Referenced by Mantid::Kernel::PropertyHistory::isEmptyDefault(), and Mantid::Kernel::Property::type().

getValueFromStdOut()

std::string Mantid::Kernel::getValueFromStdOut	(	const std::string &	orig,
		const std::string &	key
	)

Returns

the value associated with the key.

Definition at line 1087 of file ConfigService.cpp.

References Mantid::Kernel::Strings::strip().

Referenced by Mantid::Kernel::ConfigServiceImpl::getOSVersionReadable().

getWeightedZscore()

template<typename TYPE >

std::vector< double > Mantid::Kernel::getWeightedZscore	(	const std::vector< TYPE > &	data,
		const std::vector< TYPE > &	weights
	)

There are enough special cases in determining the Z score where it useful to put it in a single function.

Definition at line 104 of file Statistics.cpp.

References fabs, getStatistics(), and Mantid::Kernel::Statistics::standard_deviation.

Referenced by Mantid::Crystal::SortHKL::exec(), and Mantid::Crystal::PeakStatisticsTools::UniqueReflection::removeOutliers().

getZscore()

template<typename TYPE >

std::vector< double > Mantid::Kernel::getZscore

(

const std::vector< TYPE > &

data

)

Return the Z score values for a dataset.

There are enough special cases in determining the Z score where it useful to put it in a single function.

Definition at line 82 of file Statistics.cpp.

References fabs, getStatistics(), Mantid::Kernel::Statistics::mean, Mantid::Kernel::Statistics::standard_deviation, and tmp.

Referenced by Mantid::Algorithms::CalculateZscore::exec(), Mantid::Crystal::SortHKL::exec(), Mantid::CurveFitting::Algorithms::RefinePowderInstrumentParameters::fitInstrumentParameters(), Mantid::CurveFitting::Algorithms::RefinePowderInstrumentParameters3::genOutputWorkspace(), Mantid::CurveFitting::Algorithms::FitPowderDiffPeaks::genPeakParametersWorkspace(), and Mantid::Crystal::PeakStatisticsTools::UniqueReflection::removeOutliers().

getZscore< double >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< double >	(	const vector< double > &	,
		const bool
	)

getZscore< float >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< float >	(	const vector< float > &	,
		const bool
	)

getZscore< int >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< int >	(	const vector< int > &	,
		const bool
	)

getZscore< long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< long >	(	const vector< long > &	,
		const bool
	)

getZscore< long long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< long long >	(	const vector< long long > &	,
		const bool
	)

getZscore< unsigned int >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< unsigned int >	(	const vector< unsigned int > &	,
		const bool
	)

getZscore< unsigned long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< unsigned long >	(	const vector< unsigned long > &	,
		const bool
	)

getZscore< unsigned long long >()

template MANTID_KERNEL_DLL std::vector< double > Mantid::Kernel::getZscore< unsigned long long >	(	const vector< unsigned long long > &	,
		const bool
	)

gtEquals()

template<typename T >

MANTID_KERNEL_DLL bool Mantid::Kernel::gtEquals	(	T const	x,
		T const	y
	)

Test whether x>=y within machine precision.

Compare two floating-point numbers as to whether they satisfy x>=y within machine precision.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered <= within the machine tolerance, false otherwise

Definition at line 87 of file FloatingPointComparison.cpp.

References equals(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Geometry::crossingPoint(), and Mantid::Geometry::edgeAimsAt().

has_ending()

bool Mantid::Kernel::has_ending	(	const std::string &	value,
		const std::string &	ending
	)

Confirm that the value string ends with then ending string.

Parameters

value	:: The string to check the ending for.
ending	:: The ending the string should have.

Definition at line 110 of file FileValidator.cpp.

References value.

IPropertyManager::getValue< API::IAlgorithm_const_sptr >()

template<>

MANTID_API_DLL API::IAlgorithm_const_sptr Mantid::Kernel::IPropertyManager::getValue< API::IAlgorithm_const_sptr > ( const std::string &  name ) const

private

Get the value of a given property as the declared concrete type (const version)

Parameters

name	:: The name of the property

Returns

A pointer to an algorithm

Definition at line 2055 of file Algorithm.cpp.

References name.

IPropertyManager::getValue< API::IAlgorithm_sptr >()

template<>

MANTID_API_DLL API::IAlgorithm_sptr Mantid::Kernel::IPropertyManager::getValue< API::IAlgorithm_sptr > ( const std::string &  name ) const

private

Get the value of a given property as the declared concrete type.

Parameters

name	:: The name of the property

Returns

A pointer to an algorithm

Definition at line 2038 of file Algorithm.cpp.

References name.

IPropertyManager::getValue< Mantid::API::ExperimentInfo_const_sptr >()

template<>

MANTID_API_DLL Mantid::API::ExperimentInfo_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::ExperimentInfo_const_sptr >

(

const std::string &

name

)

const

Definition at line 1351 of file ExperimentInfo.cpp.

References name.

IPropertyManager::getValue< Mantid::API::ExperimentInfo_sptr >()

template<>

MANTID_API_DLL Mantid::API::ExperimentInfo_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::ExperimentInfo_sptr >

(

const std::string &

name

)

const

Definition at line 1338 of file ExperimentInfo.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_const_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDEventWorkspace_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_const_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.

Definition at line 83 of file IMDEventWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDEventWorkspace_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDEventWorkspace_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.

Definition at line 68 of file IMDEventWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_const_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDHistoWorkspace_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_const_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDWorkspace_const_sptr> is required.

Definition at line 52 of file IMDHistoWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDHistoWorkspace_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDHistoWorkspace_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.

Definition at line 37 of file IMDHistoWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDWorkspace_const_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDWorkspace_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDWorkspace_const_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDWorkspace_const_sptr> is required.

Definition at line 204 of file IMDWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::API::IMDWorkspace_sptr >()

template<>

MANTID_API_DLL Mantid::API::IMDWorkspace_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::API::IMDWorkspace_sptr >

(

const std::string &

name

)

const

In order to be able to cast PropertyWithValue classes correctly a definition for the PropertyWithValue<IMDEventWorkspace> is required.

Definition at line 189 of file IMDWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_const_sptr >()

template<>

DLLExport Mantid::DataObjects::EventWorkspace_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_const_sptr > ( const std::string &  name ) const

private

Definition at line 736 of file EventWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_sptr >()

template<>

DLLExport Mantid::DataObjects::EventWorkspace_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::EventWorkspace_sptr > ( const std::string &  name ) const

private

Definition at line 723 of file EventWorkspace.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_const_sptr >()

template<>

DLLExport Mantid::DataObjects::Workspace2D_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_const_sptr >

(

const std::string &

name

)

const

Definition at line 371 of file Workspace2D.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_sptr >()

template<>

DLLExport Mantid::DataObjects::Workspace2D_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::Workspace2D_sptr >

(

const std::string &

name

)

const

Definition at line 358 of file Workspace2D.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_const_sptr >()

template<>

DLLExport Mantid::DataObjects::WorkspaceSingleValue_const_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_const_sptr >

(

const std::string &

name

)

const

Definition at line 91 of file WorkspaceSingleValue.cpp.

References name.

IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_sptr >()

template<>

DLLExport Mantid::DataObjects::WorkspaceSingleValue_sptr Mantid::Kernel::IPropertyManager::getValue< Mantid::DataObjects::WorkspaceSingleValue_sptr >

(

const std::string &

name

)

const

Definition at line 77 of file WorkspaceSingleValue.cpp.

References name.

isFilter()

bool Mantid::Kernel::isFilter

(

const SplittingIntervalVec &

a

)

Return true if the SplittingIntervalVec provided is a filter, meaning that it only has an output index of 0.

Definition at line 69 of file SplittingInterval.cpp.

Referenced by operator+().

ltEquals()

template<typename T >

MANTID_KERNEL_DLL bool Mantid::Kernel::ltEquals	(	T const	x,
		T const	y
	)

Test whether x<=y within machine precision.

Compare two floating-point numbers as to whether they satisfy x<=y within machine precision.

Parameters

x	:: LHS comparator
y	:: RHS comparator

Returns

True if the numbers are considered <= within the machine tolerance, false otherwise

Definition at line 77 of file FloatingPointComparison.cpp.

References equals(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Geometry::crossingPoint(), withinAbsoluteDifference(), withinAbsoluteDifference(), withinAbsoluteDifference< V3D, double >(), withinRelativeDifference(), and withinRelativeDifference< V3D, double >().

make_cow()

template<class T , class... Args>

cow_ptr< T > Mantid::Kernel::make_cow ( Args &&...  args )

inline

Definition at line 20 of file make_cow.h.

makeCatalogConfigServiceAdapter()

template<typename T >

CatalogConfigService * Mantid::Kernel::makeCatalogConfigServiceAdapter	(	const T &	adaptee,
		const std::string &	key = "icatDownload.mountPoint"
	)

Definition at line 26 of file UserCatalogInfo.h.

References m_key.

Referenced by MantidQt::MantidWidgets::CatalogSearch::disableDownloadButtonIfArchives(), and Mantid::ICat::CatalogDownloadDataFiles::exec().

makeMDUnitFactoryChain()

MDUnitFactory_uptr Mantid::Kernel::makeMDUnitFactoryChain

(

)

Convience method. Pre-constructed builder chain.

Definition at line 51 of file MDUnitFactory.cpp.

Referenced by Mantid::Geometry::HKLFrameFactory::canInterpret(), Mantid::MDAlgorithms::ConvertCWSDMDtoHKL::createHKLMDWorkspace(), Mantid::Geometry::GeneralFrameFactory::createRaw(), Mantid::Geometry::HKLFrameFactory::createRaw(), Mantid::Geometry::UnknownFrameFactory::createRaw(), Mantid::MDAlgorithms::ImportMDEventWorkspace::exec(), and Mantid::MDAlgorithms::LoadDNSSCD::fillOutputWorkspace().

memToString() [1/2]

template<typename TYPE >

std::string Mantid::Kernel::memToString

(

const TYPE

mem_in_kiB

)

Convert a (number) for memory in kiB to a string with proper units.

Convert a (number) for memory in kiB to a string with proper units.

Definition at line 41 of file Memory.cpp.

Referenced by Mantid::Kernel::MemoryStats::availMemStr(), Mantid::Kernel::MemoryStats::resUsageStr(), Mantid::Kernel::MemoryStats::totalMemStr(), and Mantid::Kernel::MemoryStats::vmUsageStr().

memToString() [2/2]

template<typename TYPE >

string Mantid::Kernel::memToString

(

const TYPE

mem_in_kiB

)

Utility function to convert memory in kiB into easy to read units.

Convert a (number) for memory in kiB to a string with proper units.

Definition at line 41 of file Memory.cpp.

Referenced by Mantid::Kernel::MemoryStats::availMemStr(), Mantid::Kernel::MemoryStats::resUsageStr(), Mantid::Kernel::MemoryStats::totalMemStr(), and Mantid::Kernel::MemoryStats::vmUsageStr().

memToString< uint32_t >()

template DLLExport string Mantid::Kernel::memToString< uint32_t >

(

const uint32_t

)

memToString< uint64_t >()

template DLLExport string Mantid::Kernel::memToString< uint64_t >

(

const uint64_t

)

Referenced by Mantid::API::Workspace::getMemorySizeAsStr().

normalize()

MANTID_KERNEL_DLL V3D Mantid::Kernel::normalize ( V3D  v )

inline

Normalizes a V3D.

Parameters

v	a vector to normalize.

Returns

a vector with norm 1 parallel to v

Exceptions

std::runtime_error

if v is a null vector.

Definition at line 352 of file V3D.h.

References Mantid::Kernel::V3D::normalize().

Referenced by Mantid::Geometry::DetectorInfo::azimuthal(), Mantid::Geometry::DetectorInfo::azimuthal(), Mantid::MDAlgorithms::MDNormDirectSC::cacheInputs(), Mantid::MDAlgorithms::MDNormSCD::cacheInputs(), Mantid::Algorithms::MCInteractionVolume::calculateBeforeAfterTrack(), Mantid::Geometry::Rasterize::calculateCylinder(), Mantid::Algorithms::AbsorptionCorrection::calculateDistances(), Mantid::Algorithms::PaalmanPingsAbsorptionCorrection::calculateDistances(), Mantid::Algorithms::He3TubeEfficiency::calculateExponential(), Mantid::API::PanelsSurfaceCalculator::calculatePanelNormal(), Mantid::Algorithms::DetectorEfficiencyCor::correctForEfficiency(), Mantid::Algorithms::DiscusMultipleScatteringCorrection::createCollimatorHexahedronShape(), Mantid::API::DetectorSearcher::createDetectorCache(), Mantid::Geometry::ShapeFactory::createGeometryHandler(), Mantid::Algorithms::DetectorEfficiencyCor::distToSurface(), Mantid::Algorithms::He3TubeEfficiency::distToSurface(), Mantid::Algorithms::AddAbsorptionWeightedPathLengths::exec(), Mantid::Algorithms::SofQWCentre::exec(), Mantid::Algorithms::XrayAbsorptionCorrection::exec(), Mantid::MDAlgorithms::MDNorm::exec(), Mantid::DataObjects::Peak::findDetector(), Mantid::DataObjects::Peak::findDetector(), Mantid::Geometry::IndexingUtils::FormUB_From_abc_Vectors(), Mantid::CurveFitting::Algorithms::VesuvioCalculateMS::generateDetectorPos(), Mantid::Geometry::Instrument::getBeamDirection(), Mantid::DataObjects::MDHistoWorkspace::getLineData(), MDHistoWorkspaceTester::getLineData(), Mantid::DataObjects::MDEventWorkspace< MDE, nd >::getLinePlot(), Mantid::API::IMDWorkspace::getLinePlot(), Mantid::API::MatrixWorkspace::getLinePlot(), Mantid::DataObjects::MDHistoWorkspace::getLinePlot(), Mantid::DataObjects::MDHistoWorkspace::getLinePoints(), Mantid::DataObjects::MDHistoWorkspace::getNormalizationFactor(), Mantid::API::DetectorSearcher::handleTubeGap(), Mantid::API::PanelsSurfaceCalculator::isBankFlat(), Mantid::Geometry::ReferenceFrame::isVectorPointingAlongBeam(), Mantid::Crystal::lineIntersectsSphere(), Mantid::Geometry::IndexingUtils::MakeCircleDirections(), Mantid::Kernel::V3D::makeVectorsOrthogonal(), Mantid::Geometry::InstrumentDefinitionParser::makeXYplaneFaceComponent(), Mantid::Geometry::ShapeFactory::parseCone(), Mantid::Geometry::ShapeFactory::parseCuboid(), Mantid::Geometry::ShapeFactory::parseCuboid(), Mantid::Geometry::ShapeFactory::parseCylinder(), Mantid::Geometry::ShapeFactory::parseHollowCylinder(), Mantid::Geometry::ShapeFactory::parseInfiniteCone(), Mantid::Geometry::ShapeFactory::parseInfiniteCylinder(), Mantid::Geometry::ShapeFactory::parseInfinitePlane(), Mantid::Geometry::ShapeFactory::parseTaperedGuide(), Mantid::Geometry::ShapeFactory::parseTorus(), Mantid::Kernel::Quat::Quat(), Mantid::Kernel::Quat::setAngleAxis(), Mantid::Geometry::Line::setLine(), Mantid::Geometry::Cylinder::setNorm(), Mantid::Geometry::Plane::setPlane(), Mantid::Crystal::FindSXPeaksHelper::SXPeak::SXPeak(), and Mantid::DataHandling::Mantid3MFFileIO::writeMeshObject().

operator!=()

bool Mantid::Kernel::operator!=	(	const Property &	lhs,
		const Property &	rhs
	)

Compares this to another property for inequality.

Parameters

lhs	Thing on the left
rhs	Thing on the right

Returns

true if they are not equal

Definition at line 276 of file Property.cpp.

References rhs.

operator&()

SplittingIntervalVec Mantid::Kernel::operator&	(	const SplittingIntervalVec &	a,
		const SplittingIntervalVec &	b
	)

AND operator for SplittingIntervalVec Works on Filters - combines them to only keep times where both Filters are TRUE.

Works on splitter + filter if (a) is a splitter and b is a filter. In general, use the + operator since it will resolve the order for you.

Parameters

a	:: SplittingIntervalVec filter or Splitter.
b	:: SplittingIntervalVec filter.

Returns

the ANDed filter

Definition at line 120 of file SplittingInterval.cpp.

operator+()

SplittingIntervalVec Mantid::Kernel::operator+	(	const SplittingIntervalVec &	a,
		const SplittingIntervalVec &	b
	)

Plus operator for SplittingIntervalVec.

Combines a filter and a splitter by removing entries that are filtered out from the splitter. Also, will combine two filters together by "and"ing them

Parameters

a	:: SplittingIntervalVec splitter OR filter
b	:: SplittingIntervalVec splitter OR filter.

Exceptions

std::invalid_argument

if two splitters are given.

Definition at line 88 of file SplittingInterval.cpp.

References isFilter().

operator<<() [1/19]

template<class _CharT , class _Traits , class _RT >

std::basic_ostream< _CharT, _Traits > & Mantid::Kernel::operator<<	(	std::basic_ostream< _CharT, _Traits > &	__os,
		const normal_distribution< _RT > &	__x
	)

Definition at line 141 of file normal_distribution.h.

operator<<() [2/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const VMDBase< float > &	v
	)

Definition at line 559 of file VMD.cpp.

References Mantid::Kernel::VMDBase< TYPE >::toString().

operator<<() [3/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	buffer,
		const InstrumentInfo &	instrumentDescriptor
	)

Allow this object to be printed to a stream.

Prints the instrument name to the stream.

Parameters

buffer	:: A reference to an output stream
instrumentDescriptor	:: A reference to an InstrumentInfo object

Returns

A reference to the stream written to

Definition at line 293 of file InstrumentInfo.cpp.

References Mantid::Kernel::InstrumentInfo::name().

operator<<() [4/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	buffer,
		const LiveListenerInfo &	listener
	)

Allow this object to be printed to a stream.

Prints the listener to the stream.

Parameters

buffer	:: A reference to an output stream
listener	:: A reference to a LiveListenerInfo object

Returns

A reference to the stream written to

Definition at line 75 of file LiveListenerInfo.cpp.

References Mantid::Kernel::LiveListenerInfo::address(), Mantid::Kernel::LiveListenerInfo::listener(), and Mantid::Kernel::LiveListenerInfo::name().

operator<<() [5/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	buffer,
		const TopicInfo &	topic
	)

Allow this object to be printed to a stream.

Prints the listener to the stream.

Parameters

buffer	:: A reference to an output stream
topic	:: A reference to a TopicInfo object

Returns

A reference to the stream written to

Definition at line 69 of file TopicInfo.cpp.

References Mantid::Kernel::TopicInfo::name(), and Mantid::Kernel::TopicInfo::type().

operator<<() [6/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const EnvironmentHistory &	EH
	)

Prints a text representation.

Parameters

os	:: The ouput stream to write to
EH	:: The EnvironmentHistory to output

Returns

The ouput stream

Definition at line 49 of file EnvironmentHistory.cpp.

References Mantid::Kernel::EnvironmentHistory::printSelf().

operator<<() [7/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const Interpolation &	f
	)

Prints the value of parameter.

Parameters

os	:: the Stream to output to
f	:: the FitParameter to output

Returns

the output stream

Definition at line 158 of file Interpolation.cpp.

References Mantid::Kernel::Interpolation::printSelf().

operator<<() [8/19]

template<typename T >

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const Matrix< T > &	matrix
	)

Write an object to a stream.

Format will be Matrix(nrows,ncols)x_00,x_01...,x_10,x_11

Parameters

os	:: output stream
matrix	:: Matrix to write out

Returns

The output stream (of)

Definition at line 1584 of file Matrix.cpp.

References dumpToStream().

operator<<() [9/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const PropertyHistory &	AP
	)

Prints a text representation.

Parameters

os	:: The output stream to write to
AP	:: The PropertyHistory to output

Returns

The output stream

Definition at line 56 of file PropertyHistory.cpp.

References Mantid::Kernel::PropertyHistory::printSelf().

operator<<() [10/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const Quat &	q
	)

Prints a string representation.

Parameters

os	:: the stream to output to
q	:: the quat to output

Returns

the stream

Definition at line 642 of file Quat.cpp.

References Mantid::Kernel::Quat::printSelf().

operator<<() [11/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const V2D &	point
	)

Output stream operator.

Parameters

os	:: An output stream
point	:: The V2D to send to the stream

Definition at line 51 of file V2D.cpp.

References Mantid::Kernel::V2D::X(), and Mantid::Kernel::V2D::Y().

operator<<() [12/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const V3D &	v
	)

Prints a text representation of itself.

Parameters

os	:: the Stream to output to
v	:: the vector to output

Returns

the output stream

Definition at line 382 of file V3D.cpp.

References Mantid::Kernel::V3D::printSelf().

operator<<() [13/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		const VMDBase< double > &	v
	)

Prints a text representation of itself.

Parameters

os	:: the Stream to output to
v	:: the vector to output

Returns

the output stream

Definition at line 554 of file VMD.cpp.

References Mantid::Kernel::VMDBase< TYPE >::toString().

operator<<() [14/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	os,
		OptionalBool const &	object
	)

Definition at line 68 of file OptionalBool.cpp.

operator<<() [15/19]

MANTID_KERNEL_DLL std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	out,
		const CodeBlockMultipleTimer::TimeAccumulator &	ta
	)

Output timing summary to a stream.

Parameters

out	:: stream to output the timing summary
ta	:: time accumulator keeping the timing summary

Returns

:: stream to output the timing summary

Definition at line 140 of file Timer.cpp.

References Mantid::Kernel::CodeBlockMultipleTimer::TimeAccumulator::toString().

operator<<() [16/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	out,
		const MemoryStats &	stats
	)

Convenience function for writting out to stream.

Definition at line 468 of file Memory.cpp.

operator<<() [17/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	out,
		const Timer &	obj
	)

Convenience function to provide for easier debug printing.

Definition at line 58 of file Timer.cpp.

References obj.

operator<<() [18/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	out,
		CPUTimer &	obj
	)

Convenience function to provide for easier debug printing.

Definition at line 86 of file CPUTimer.cpp.

References obj.

operator<<() [19/19]

std::ostream & Mantid::Kernel::operator<<	(	std::ostream &	s,
		const Mantid::Kernel::TimeInterval &	t
	)

Definition at line 98 of file DateAndTime.cpp.

operator==()

bool Mantid::Kernel::operator==	(	const Property &	lhs,
		const Property &	rhs
	)

Compares this to another property for equality.

Parameters

lhs	Thing on the left
rhs	Thing on the right

Returns

true if they are equal

Definition at line 244 of file Property.cpp.

References Mantid::Kernel::Property::name(), rhs, Mantid::Kernel::Property::type(), and Mantid::Kernel::Property::value().

Referenced by Mantid::Kernel::Matrix< T >::operator!=(), Mantid::Kernel::VMDBase< TYPE >::operator!=(), and Mantid::Kernel::FilteredTimeSeriesProperty< HeldType >::operator==().

operator>>() [1/6]

template<class _CharT , class _Traits , class _RT >

std::basic_istream< _CharT, _Traits > & Mantid::Kernel::operator>>	(	std::basic_istream< _CharT, _Traits > &	__is,
		normal_distribution< _RT > &	__x
	)

Definition at line 179 of file normal_distribution.h.

operator>>() [2/6]

std::istream & Mantid::Kernel::operator>>	(	std::istream &	in,
		Interpolation &	f
	)

Reads in parameter value.

Parameters

in	:: Input Stream
f	:: FitParameter to write to

Returns

Current state of stream

Definition at line 169 of file Interpolation.cpp.

References Mantid::Kernel::Interpolation::addPoint(), Mantid::Kernel::StringTokenizer::count(), Mantid::Kernel::Interpolation::resetData(), Mantid::Kernel::Interpolation::setMethod(), Mantid::Kernel::Interpolation::setXUnit(), Mantid::Kernel::Interpolation::setYUnit(), Mantid::Kernel::StringTokenizer::TOK_TRIM, Mantid::Geometry::x, and Mantid::Geometry::y.

operator>>() [3/6]

std::istream & Mantid::Kernel::operator>>	(	std::istream &	ins,
		Quat &	q
	)

Reads in a quat from an input stream.

Parameters

ins	:: The input stream
q	:: The quat

Definition at line 651 of file Quat.cpp.

References Mantid::Kernel::Quat::readPrinted().

operator>>() [4/6]

template<typename T >

std::istream & Mantid::Kernel::operator>>	(	std::istream &	is,
		Kernel::Matrix< T > &	in
	)

Fill an object from a stream.

Format should be Matrix(nrows,ncols)x_00,x_01...,x_10,x_11

Parameters

is	:: A stream object
in	:: An object to fill

Returns

A reference to the stream

Definition at line 1615 of file Matrix.cpp.

References fillFromStream().

operator>>() [5/6]

std::istream & Mantid::Kernel::operator>>	(	std::istream &	istream,
		OptionalBool &	object
	)

Definition at line 73 of file OptionalBool.cpp.

operator>>() [6/6]

std::istream & Mantid::Kernel::operator>>	(	std::istream &	IX,
		V3D &	A
	)

Calls Vec3D method write to output class.

Parameters

IX	:: Input Stream
A	:: Vec3D to write

Returns

Current state of stream

Definition at line 387 of file V3D.cpp.

References Mantid::Kernel::V3D::readPrinted().

operator|()

SplittingIntervalVec Mantid::Kernel::operator|	(	const SplittingIntervalVec &	a,
		const SplittingIntervalVec &	b
	)

OR operator for SplittingIntervalVec Only works on Filters, not splitters.

Combines the splitters to only keep times where EITHER Filter is TRUE.

Parameters

a	:: SplittingIntervalVec filter.
b	:: SplittingIntervalVec filter.

Returns

the ORed filter

Definition at line 187 of file SplittingInterval.cpp.

References left, removeFilterOverlap(), right, and value.

operator~()

SplittingIntervalVec Mantid::Kernel::operator~

(

const SplittingIntervalVec &

a

)

NOT operator for SplittingIntervalVec Only works on Filters.

Returns a filter with the reversed time intervals as the incoming filter.

Parameters

a	:: SplittingIntervalVec filter.

Definition at line 212 of file SplittingInterval.cpp.

References removeFilterOverlap().

parallel_minmax() [1/3]

template<typename T >

std::pair< T, T > Mantid::Kernel::parallel_minmax	(	std::shared_ptr< std::vector< T > > const &	vec,
		size_t const	grainsize = 1000
	)

parallel_minmax

Parameters

vec	– a shared pointer to a vector of values of type T, to search for a min and max
grainsize	– the grainsize for use in tbb::parallel_reduce. Default = 1000

Returns

a std::pair<T,T> with the min (first) and max (second)

Definition at line 55 of file ParallelMinMax.cpp.

References vec.

parallel_minmax() [2/3]

template<typename T >

std::pair< T, T > Mantid::Kernel::parallel_minmax	(	std::unique_ptr< std::vector< T > > const &	vec,
		size_t const	grainsize = 1000
	)

parallel_minmax

Parameters

vec	– a unique pointer to a vector of values of type T, to search for a min and max
grainsize	– the grainsize for use in tbb::parallel_reduce. Default = 1000

Returns

a std::pair<T,T> with the min (first) and max (second)

Definition at line 60 of file ParallelMinMax.cpp.

References vec.

parallel_minmax() [3/3]

template<typename T >

std::pair< T, T > Mantid::Kernel::parallel_minmax	(	std::vector< T > const *const	vec,
		size_t const	grainsize = 1000
	)

parallel_minmax

Parameters

vec	– a pointer to a vector of values of type T, to search for a min and max
grainsize	– the grainsize for use in tbb::parallel_reduce. Default = 1000

Returns

a std::pair<T,T> with the min (first) and max (second)

Definition at line 43 of file ParallelMinMax.cpp.

References maxval, minval, and vec.

Referenced by Mantid::DataHandling::AlignAndFocusPowderSlim::ProcessBankSplitFullTimeTask::operator()(), Mantid::DataHandling::AlignAndFocusPowderSlim::ProcessBankSplitTask::operator()(), Mantid::DataHandling::AlignAndFocusPowderSlim::ProcessBankTask::operator()(), and Mantid::DataHandling::LoadBankFromDiskTask::run().

process_mem_usage()

void Mantid::Kernel::process_mem_usage	(	size_t &	vm_usage,
		size_t &	resident_set
	)

Attempts to read the system-dependent data for a process' virtual memory size and resident set size, and return the results in KB.

On failure, returns 0.0, 0.0

Parameters

vm_usage	:: The virtual memory usage is stored in this variable in KiB
resident_set,:	The memory associated with the current process in KiB

Definition at line 60 of file Memory.cpp.

Referenced by Mantid::Kernel::MemoryStats::update().

relativeDifference() [1/2]

template<typename T >

MANTID_KERNEL_DLL T Mantid::Kernel::relativeDifference	(	T const	x,
		T const	y
	)

Calculate relative difference between x, y.

Calculate relative difference between x, y.

Parameters

x	:: first value
y	:: second value

Returns

the value of the relative difference. Do NOT use this to compare the result to a tolerance; for that, use withinRelativeDifference instead, as it will be more efficient at the comparison.

Definition at line 114 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

relativeDifference() [2/2]

template<typename T >

T Mantid::Kernel::relativeDifference	(	T const	x,
		T const	y
	)

Calculate the relative difference of two floating-point numbers.

Calculate relative difference between x, y.

Parameters

x	:: first value
y	:: second value

Returns

the value of the relative difference. Do NOT use this to compare the result to a tolerance; for that, use withinRelativeDifference instead, as it will be more efficient at the comparison.

Definition at line 114 of file FloatingPointComparison.cpp.

References Mantid::Geometry::x, and Mantid::Geometry::y.

removeFilterOverlap()

SplittingIntervalVec Mantid::Kernel::removeFilterOverlap

(

const SplittingIntervalVec &

a

)

Remove any overlap in a filter (will not work properly on a splitter)

Parameters

a	:: SplittingIntervalVec filter.

Definition at line 151 of file SplittingInterval.cpp.

Referenced by operator|(), and operator~().

swap()

void Mantid::Kernel::swap	(	MultiFileValidator &	obj1,
		MultiFileValidator &	obj2
	)

Definition at line 27 of file MultiFileValidator.cpp.

Referenced by Mantid::Kernel::LibraryWrapper::operator=(), and Mantid::Kernel::Logger::setName().

threadSafe() [1/4]

template<typename Arg >

std::enable_if< std::is_pointer< Arg >::value, bool >::type Mantid::Kernel::threadSafe ( Arg  workspace )

inline

Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.

NULL workspaces are assumed suitable

Parameters

workspace

pointer to workspace to verify.

Returns

Whether workspace is threadsafe.

Definition at line 22 of file MultiThreaded.h.

References workspace.

Referenced by Mantid::DataHandling::LoadILLSANS::adjustTOF(), Mantid::Algorithms::PolarizationCorrectionWildes::analyzerlessCorrections(), Mantid::Algorithms::Q1DWeighted::calculate(), Mantid::Algorithms::FitPeaks::calculateFittedPeaks(), Mantid::Algorithms::MultipleScatteringCorrection::calculateL12s(), Mantid::Algorithms::MultipleScatteringCorrection::calculateL12s(), Mantid::Algorithms::DetectorDiagnostic::calculateMedian(), Mantid::MDAlgorithms::MDNorm::calculateNormalization(), Mantid::MDAlgorithms::MDNormSCD::calculateNormalization(), Mantid::Algorithms::MultipleScatteringCorrection::calculateSampleAndContainer(), Mantid::Algorithms::MultipleScatteringCorrection::calculateSingleComponent(), Mantid::Algorithms::ResetNegatives::changeNegatives(), Mantid::Algorithms::ConvertUnits::convertQuickly(), Mantid::Algorithms::ConvertUnits::convertViaTOF(), Mantid::Algorithms::CorrectTOFAxis::correctManually(), Mantid::Algorithms::SumEventsByLogValue::createBinnedOutput(), Mantid::DataObjects::MDEventWorkspace< MDE, nd >::createIterators(), Mantid::Algorithms::Bin2DPowderDiffraction::createOutputWorkspace(), Mantid::DataHandling::CreateSimulationWorkspace::createOutputWorkspace(), Mantid::Algorithms::SumEventsByLogValue::createTableOutput(), Mantid::Algorithms::PolarizationCorrectionWildes::directBeamCorrections(), Mantid::Algorithms::BinaryOperation::do2D(), Mantid::Algorithms::DetectorEfficiencyVariation::doDetectorTests(), Mantid::Algorithms::MedianDetectorTest::doDetectorTests(), Mantid::Algorithms::RebinByPulseTimes::doHistogramming(), Mantid::Algorithms::RebinByTimeAtSample::doHistogramming(), Mantid::Algorithms::MonteCarloAbsorption::doSimulation(), Mantid::Algorithms::BinaryOperation::doSingleColumn(), Mantid::Algorithms::BinaryOperation::doSingleSpectrum(), Mantid::Algorithms::BinaryOperation::doSingleValue(), Mantid::Algorithms::Arithmetic::ErrorPropagation< N, Func >::evaluateWorkspacesImpl(), Mantid::Algorithms::AbsorptionCorrection::exec(), Mantid::Algorithms::AddAbsorptionWeightedPathLengths::exec(), Mantid::Algorithms::ApplyTransmissionCorrection::exec(), Mantid::Algorithms::CalculateCarpenterSampleCorrection::exec(), Mantid::Algorithms::CalculateFlatBackground::exec(), Mantid::Algorithms::CalculatePlaczek::exec(), Mantid::Algorithms::CalculatePolynomialBackground::exec(), Mantid::Algorithms::CarpenterSampleCorrection::exec(), Mantid::Algorithms::ChopData::exec(), Mantid::Algorithms::ConjoinXRuns::exec(), Mantid::Algorithms::ConvertAxesToRealSpace::exec(), Mantid::Algorithms::ConvertAxisByFormula::exec(), Mantid::Algorithms::ConvertToConstantL2::exec(), Mantid::Algorithms::ConvertToEventWorkspace::exec(), Mantid::Algorithms::ConvertToMatrixWorkspace::exec(), Mantid::Algorithms::CorelliCrossCorrelate::exec(), Mantid::Algorithms::CorrectKiKf::exec(), Mantid::Algorithms::CreatePSDBleedMask::exec(), Mantid::Algorithms::CreateWorkspace::exec(), Mantid::Algorithms::CropWorkspaceRagged::exec(), Mantid::Algorithms::CrossCorrelate::exec(), Mantid::Algorithms::DeadTimeCorrection::exec(), Mantid::Algorithms::DetectorEfficiencyCor::exec(), Mantid::Algorithms::DetectorEfficiencyCorUser::exec(), Mantid::Algorithms::DiffractionFocussing2::exec(), Mantid::Algorithms::DirectILLTubeBackground::exec(), Mantid::Algorithms::DiscusMultipleScatteringCorrection::exec(), Mantid::Algorithms::EQSANSCorrectFrame::exec(), Mantid::Algorithms::ExtractFFTSpectrum::exec(), Mantid::Algorithms::FilterByXValue::exec(), Mantid::Algorithms::FindEPP::exec(), Mantid::Algorithms::FindPeaksConvolve::exec(), Mantid::Algorithms::GetDetectorOffsets::exec(), Mantid::Algorithms::He3TubeEfficiency::exec(), Mantid::Algorithms::HyspecScharpfCorrection::exec(), Mantid::Algorithms::IntegrateByComponent::exec(), Mantid::Algorithms::Integration::exec(), Mantid::Algorithms::MaskBinsIf::exec(), Mantid::Algorithms::MaxMin::exec(), Mantid::Algorithms::ModeratorTzero::exec(), Mantid::Algorithms::ModeratorTzeroLinear::exec(), Mantid::Algorithms::MonitorEfficiencyCorUser::exec(), Mantid::Algorithms::MultiplyRange::exec(), Mantid::Algorithms::PaalmanPingsAbsorptionCorrection::exec(), Mantid::Algorithms::PaddingAndApodization::exec(), Mantid::Algorithms::PointByPointVCorrection::exec(), Mantid::Algorithms::Q1D2::exec(), Mantid::Algorithms::Rebin::exec(), Mantid::Algorithms::Rebin2D::exec(), Mantid::Algorithms::RebinRagged::exec(), Mantid::Algorithms::Rebunch::exec(), Mantid::Algorithms::RemoveBackground::exec(), Mantid::Algorithms::ResampleX::exec(), Mantid::Algorithms::ResetNegatives::exec(), Mantid::Algorithms::MayersSampleCorrection::exec(), Mantid::Algorithms::ScaleX::exec(), Mantid::Algorithms::SetUncertainties::exec(), Mantid::Algorithms::SmoothData::exec(), Mantid::Algorithms::SofQWNormalisedPolygon::exec(), Mantid::Algorithms::SofQWPolygon::exec(), Mantid::Algorithms::SolidAngle::exec(), Mantid::Algorithms::SortXAxis::exec(), Mantid::Algorithms::TOFSANSResolution::exec(), Mantid::Algorithms::Transpose::exec(), Mantid::Algorithms::UnaryOperation::exec(), Mantid::Algorithms::UnwrapSNS::exec(), Mantid::Algorithms::XDataConverter::exec(), Mantid::Crystal::AnvredCorrection::exec(), Mantid::Crystal::FindSXPeaks::exec(), Mantid::Crystal::IntegratePeaksHybrid::exec(), Mantid::Crystal::IntegratePeaksUsingClusters::exec(), Mantid::Crystal::MaskPeaksWorkspace::exec(), Mantid::Crystal::NormaliseVanadium::exec(), Mantid::Crystal::PeakIntegration::exec(), Mantid::Crystal::SCDCalibratePanels::exec(), Mantid::CurveFitting::Algorithms::ConvertToYSpace::exec(), Mantid::CurveFitting::Algorithms::ConvolveWorkspaces::exec(), Mantid::CurveFitting::Algorithms::VesuvioCalculateGammaBackground::exec(), Mantid::CurveFitting::Algorithms::VesuvioCalculateMS::exec(), Mantid::DataHandling::LoadILLPolarizationFactors::exec(), Mantid::MDAlgorithms::CalculateCoverageDGS::exec(), Mantid::MDAlgorithms::ConvertToDiffractionMDWorkspace::exec(), Mantid::MDAlgorithms::IntegratePeaksMDHKL::exec(), Mantid::MDAlgorithms::ThresholdMD::exec(), Mantid::WorkflowAlgorithms::SANSSolidAngleCorrection::exec(), Mantid::Algorithms::CorrectKiKf::execEvent(), Mantid::Algorithms::DiffractionFocussing2::execEvent(), Mantid::Algorithms::ExtractSpectra::execEvent(), Mantid::Algorithms::He3TubeEfficiency::execEvent(), Mantid::Algorithms::HyspecScharpfCorrection::execEvent(), Mantid::Algorithms::MaskBins::execEvent(), Mantid::Algorithms::ModeratorTzeroLinear::execEvent(), Mantid::Algorithms::ScaleX::execEvent(), Mantid::Algorithms::UnaryOperation::execEvent(), Mantid::Crystal::AnvredCorrection::execEvent(), Mantid::WorkflowAlgorithms::SANSSolidAngleCorrection::execEvent(), Mantid::Algorithms::EQSANSTofStructure::execEvent(), Mantid::Algorithms::ModeratorTzero::execEvent(), Mantid::Algorithms::SmoothNeighbours::execEvent(), Mantid::Crystal::PeaksIntersection::executePeaksIntersection(), Mantid::Algorithms::SmoothNeighbours::execWorkspace2D(), Mantid::Algorithms::WorkspaceJoiners::execWS2D(), Mantid::Algorithms::Q1DWeighted::fillMonochromaticOutput(), Mantid::MDAlgorithms::LoadDNSSCD::fillOutputWorkspace(), Mantid::MDAlgorithms::LoadDNSSCD::fillOutputWorkspaceRaw(), Mantid::Algorithms::Q1DWeighted::fillTOFOutput(), Mantid::DataObjects::RebinnedOutput::finalize(), Mantid::Crystal::SCDCalibratePanels::findL2(), Mantid::Algorithms::PolarizationCorrectionWildes::fullCorrections(), Mantid::Algorithms::RebinToWorkspace::histogram(), Mantid::Crystal::CentroidPeaks::integrate(), Mantid::MDAlgorithms::IntegratePeaksMD2::integrate(), Mantid::Crystal::CentroidPeaks::integrateEvent(), Mantid::Algorithms::DiscusMultipleScatteringCorrection::interpolateFromSparse(), Mantid::Algorithms::MonteCarloAbsorption::interpolateFromSparse(), Mantid::DataHandling::LoadILLIndirect2::loadDiffractionData(), Mantid::Algorithms::Stitch1D::maskAllBut(), Mantid::Algorithms::Stitch1D::maskInPlace(), Mantid::Algorithms::MedianDetectorTest::maskOutliers(), Mantid::Algorithms::CalculateEfficiency2::mergeGroup(), Mantid::Algorithms::CalculateIqt::monteCarloErrorCalculation(), Mantid::Algorithms::NormaliseToMonitor::normaliseBinByBin(), Mantid::Crystal::SCDCalibratePanels2::optimizeBanks(), Mantid::Algorithms::SumOverlappingTubes::performBinning(), Mantid::Algorithms::NormaliseToMonitor::performHistogramDivision(), Mantid::DataHandling::LoadDNSEvent::populate_EventWorkspace(), Mantid::Algorithms::CreateDetectorTable::populateTable(), Mantid::Algorithms::NormaliseByDetector::processHistograms(), Mantid::Algorithms::LorentzCorrection::processTOF_PD(), Mantid::Algorithms::LorentzCorrection::processTOF_SCD(), Mantid::Crystal::SCDCalibratePanels2::profileBanks(), Mantid::Algorithms::ResetNegatives::pushMinimum(), Mantid::MDAlgorithms::IntegrateEllipsoidsTwoStep::qListFromEventWS(), Mantid::MDAlgorithms::IntegrateEllipsoidsV1::qListFromEventWS(), Mantid::MDAlgorithms::IntegrateEllipsoidsV2::qListFromEventWS(), Mantid::MDAlgorithms::IntegrateEllipsoidsTwoStep::qListFromHistoWS(), Mantid::MDAlgorithms::IntegrateEllipsoidsV1::qListFromHistoWS(), Mantid::MDAlgorithms::IntegrateEllipsoidsV2::qListFromHistoWS(), Mantid::Algorithms::RebinToWorkspace::rebin(), Mantid::Algorithms::Stitch1D::rebin(), Mantid::Algorithms::Stitch::recordScaleFactor(), Mantid::Algorithms::Stitch1D::reinsertSpecialValues(), Mantid::Algorithms::CreateFloodWorkspace::removeBackground(), Mantid::Algorithms::ConvertUnits::reverse(), Mantid::Algorithms::Stitch::scaleManual(), Mantid::Algorithms::CreateFloodWorkspace::scaleToCentralPixel(), Mantid::Algorithms::CalculateIqt::setErrorsToStandardDeviation(), Mantid::Algorithms::CalculateIqt::setErrorsToZero(), Mantid::Algorithms::ConvertUnits::setupOutputWorkspace(), Mantid::API::IMDEventWorkspace::splitAllIfNeeded(), Mantid::CurveFitting::Algorithms::NormaliseByPeakArea::symmetriseYSpace(), threadSafe(), threadSafe(), Mantid::Algorithms::PolarizationCorrectionWildes::threeInputsSolve01(), Mantid::Algorithms::PolarizationCorrectionWildes::threeInputsSolve10(), Mantid::Algorithms::PolarizationCorrectionWildes::twoInputsSolve01And10(), Mantid::DataObjects::RebinnedOutput::unfinalize(), Mantid::Algorithms::CorrectTOFAxis::useReferenceWorkspace(), and Mantid::DataHandling::EventWorkspaceCollection::~EventWorkspaceCollection().

threadSafe() [2/4]

template<typename Arg , typename... Args>

std::enable_if< std::is_pointer< Arg >::value, bool >::type Mantid::Kernel::threadSafe ( Arg  workspace, Args &&...  others  )

inline

Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.

NULL workspaces are assumed suitable

Parameters

workspace	pointer to workspace to verify.
others	pointers to all other workspaces which need to be checked.

Returns

whether workspace is threadsafe.

Definition at line 34 of file MultiThreaded.h.

References threadSafe(), and workspace.

threadSafe() [3/4]

template<typename Arg >

std::enable_if<!std::is_pointer< Arg >::value, bool >::type Mantid::Kernel::threadSafe ( const Arg &  workspace )

inline

Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.

Parameters

workspace

reference to workspace to verify.

Returns

Whether workspace is threadsafe.

Definition at line 44 of file MultiThreaded.h.

References workspace.

threadSafe() [4/4]

template<typename Arg , typename... Args>

std::enable_if<!std::is_pointer< Arg >::value, bool >::type Mantid::Kernel::threadSafe ( const Arg &  workspace, Args &&...  others  )

inline

Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.

Parameters

workspace	reference to workspace to verify.
others	references or pointers to all other workspaces which need to be checked.

Returns

whether workspace is threadsafe.

Definition at line 56 of file MultiThreaded.h.

References threadSafe(), and workspace.

timeMean()

double Mantid::Kernel::timeMean	(	const Kernel::Property *	p,
		const Kernel::TimeROI *	roi
	)

Returns the mean value if the property is TimeSeriesProperty<double>

Returns the time-weighted mean value if the property is TimeSeriesProperty<double>.

TODO: Make this more efficient.

Parameters

p	:: Property with the data. Will throw if not TimeSeriesProperty<double>.
roi	:: TimeROI for when the log is being used

Returns

The mean value over time.

Exceptions

runtime_error

if the property is not TimeSeriesProperty<double>

Definition at line 314 of file LogParser.cpp.

Referenced by Mantid::Geometry::XMLInstrumentParameter::createParamValue().

timeROIsFromSplitters()

std::map< int, Kernel::TimeROI > Mantid::Kernel::timeROIsFromSplitters

(

const SplittingIntervalVec &

splitters

)

For every workspace index, create a TimeROI out of its associated splitting intervals.

Parameters

splitters

:: vector of splitting intervals, each interval has an associated workspace index

Returns

map from workspace index to TimeROI object

Definition at line 250 of file SplittingInterval.cpp.

toPrettyString() [1/7]

template<typename T >

std::string Mantid::Kernel::toPrettyString	(	const std::shared_ptr< T > &	value,
		size_t	maxLength = 0,
		bool	collapseLists = true
	)

Throw an exception if a shared pointer is converted to a pretty string.

Definition at line 72 of file PropertyHelper.h.

References UNUSED_ARG, and value.

toPrettyString() [2/7]

template<>

std::string Mantid::Kernel::toPrettyString ( const std::vector< bool > &  value, size_t  maxLength, bool  collapseLists, const std::string &  delimiter, const std::string &  unusedDelimiter, typename std::enable_if< std::is_same< bool, bool >::value >::type *    )

inline

Explicit specialization for a property of type std::vector<bool>.

This will catch Vectors of char, double, float etc. This simply concatenates the values using a delimiter

Definition at line 121 of file PropertyHelper.h.

References Mantid::Kernel::Strings::join(), Mantid::Kernel::Strings::shorten(), UNUSED_ARG, and value.

toPrettyString() [3/7]

template<typename T >

std::string Mantid::Kernel::toPrettyString	(	const std::vector< std::vector< T > > &	value,
		size_t	maxLength = 0,
		bool	collapseLists = true,
		const std::string &	outerDelimiter = ",",
		const std::string &	innerDelimiter = "+"
	)

Specialization for a property of type std::vector<std::vector>.

Definition at line 131 of file PropertyHelper.h.

References Mantid::Kernel::Strings::shorten(), UNUSED_ARG, and value.

toPrettyString() [4/7]

template<typename T >

std::string Mantid::Kernel::toPrettyString	(	const std::vector< T > &	value,
		size_t	maxLength = 0,
		bool	collapseLists = true,
		const std::string &	delimiter = ",",
		const std::string &	listDelimiter = "-",
		typename std::enable_if< std::is_integral< T >::value &&std::is_arithmetic< T >::value >::type *	= nullptr
	)

Specialization for a property of type std::vector of integral types.

This will catch Vectors of int, long, long long etc including signed and unsigned types of these. This concatenates the values using a delimiter, adjacent items that are precisely 1 away from each other will be compressed into a list syntax e.g. 1-5.

Definition at line 102 of file PropertyHelper.h.

References Mantid::Kernel::Strings::join(), Mantid::Kernel::Strings::joinCompress(), Mantid::Kernel::Strings::shorten(), and value.

toPrettyString() [5/7]

template<typename T >

std::string Mantid::Kernel::toPrettyString	(	const std::vector< T > &	value,
		size_t	maxLength = 0,
		bool	collapseLists = true,
		const std::string &	delimiter = ",",
		const std::string &	unusedDelimiter = "+",
		typename std::enable_if<!(std::is_integral< T >::value &&std::is_arithmetic< T >::value)>::type *	= nullptr
	)

Specialization for a property of type std::vector of non integral types.

This will catch Vectors of char, double, float etc. This simply concatenates the values using a delimiter

Definition at line 84 of file PropertyHelper.h.

References Mantid::Kernel::Strings::join(), Mantid::Kernel::Strings::shorten(), UNUSED_ARG, and value.

toPrettyString() [6/7]

template<typename T >

std::string Mantid::Kernel::toPrettyString	(	const T &	value,
		size_t	maxLength = 0,
		bool	collapseLists = true
	)

Convert values to pretty strings.

Definition at line 65 of file PropertyHelper.h.

References Mantid::Kernel::Strings::shorten(), UNUSED_ARG, and value.

Referenced by Mantid::Kernel::PropertyWithValue< TYPE >::valueAsPrettyStr(), and Mantid::Kernel::EnumeratedStringProperty< E, names >::valueAsPrettyStr().

toPrettyString() [7/7]

template<>

std::string Mantid::Kernel::toPrettyString	(	PythonObject const &	value,
		size_t	,
		bool
	)

Creates a pretty string representation of the object.

In this case it matches the simple string case.

Definition at line 125 of file PythonObjectProperty.cpp.

References toString(), and value.

toQuat()

Kernel::Quat Mantid::Kernel::toQuat ( const Eigen::Quaterniond &  quat )

inline

Converts Eigen::Quaterniond to Kernel::Quat.

Definition at line 29 of file EigenConversionHelpers.h.

Referenced by Mantid::Geometry::Instrument::makeLegacyParameterMap(), Mantid::Geometry::ComponentInfo::relativeRotation(), Mantid::Geometry::ComponentInfo::rotation(), Mantid::Geometry::DetectorInfo::rotation(), Mantid::Geometry::ComponentInfo::rotation(), and Mantid::Geometry::DetectorInfo::rotation().

toQuaterniond()

Eigen::Quaterniond Mantid::Kernel::toQuaterniond ( const Kernel::Quat &  quat )

inline

Converts Kernel::Quat to Eigen::Quaterniond.

Definition at line 37 of file EigenConversionHelpers.h.

References Mantid::Kernel::Quat::imagI(), Mantid::Kernel::Quat::imagJ(), Mantid::Kernel::Quat::imagK(), and Mantid::Kernel::Quat::real().

Referenced by Mantid::API::applyRectangularDetectorScaleToComponentInfo(), Mantid::Geometry::InstrumentVisitor::commonRegistration(), Mantid::Geometry::Instrument::makeLegacyParameterMap(), Mantid::Geometry::ComponentInfoBankHelpers::offsetFromAncestor(), Mantid::Geometry::InstrumentVisitor::registerDetector(), Mantid::Geometry::DetectorInfo::setRotation(), Mantid::Geometry::ComponentInfo::setRotation(), Mantid::Geometry::DetectorInfo::setRotation(), and Mantid::Geometry::ComponentInfo::setRotation().

toString() [1/5]

template<typename T >

std::string Mantid::Kernel::toString

(

const std::shared_ptr< T > &

)

Throw an exception if a shared pointer is converted to a string.

Definition at line 29 of file PropertyHelper.h.

References toString().

toString() [2/5]

template<typename T >

std::string Mantid::Kernel::toString	(	const std::vector< std::vector< T > > &	value,
		const std::string &	outerDelimiter = ",",
		const std::string &	innerDelimiter = "+"
	)

Specialization for a property of type std::vector<std::vector>.

Definition at line 45 of file PropertyHelper.h.

References toString(), and value.

toString() [3/5]

template<typename T >

std::string Mantid::Kernel::toString	(	const std::vector< T > &	value,
		const std::string &	delimiter = ","
	)

Specialization for a property of type std::vector.

Definition at line 32 of file PropertyHelper.h.

References toString(), and value.

toString() [4/5]

template<typename T >

std::string Mantid::Kernel::toString

(

const T &

value

)

Convert values to strings.

Definition at line 26 of file PropertyHelper.h.

References toString(), and value.

Referenced by Mantid::WorkflowAlgorithms::SANSBeamFluxCorrection::exec(), Mantid::API::MultipleFileProperty::getDefault(), Mantid::Kernel::PropertyWithValue< TYPE >::getDefault(), Mantid::PythonInterface::PythonObjectProperty::getDefault(), Mantid::Kernel::PropertyWithValue< TYPE >::getValueForAlias(), Mantid::Geometry::IDFObject::IDFObject(), Mantid::API::IMDEventWorkspace::IMDEventWorkspace(), Mantid::API::IMDHistoWorkspace::IMDHistoWorkspace(), Mantid::API::IMDWorkspace::IMDWorkspace(), Mantid::API::IPeaksWorkspace::IPeaksWorkspace(), MantidQt::MantidWidgets::FitOptionsBrowser::loadSettings(), Mantid::DataObjects::MaskWorkspace::MaskWorkspace(), Mantid::Kernel::PropertyWithValue< TYPE >::operator=(), Mantid::Geometry::InstrumentDefinitionParser::setupGeometryCache(), Mantid::DataObjects::SpecialWorkspace2D::SpecialWorkspace2D(), Mantid::Kernel::MultiFileNameParsing::suggestWorkspaceName(), Mantid::Kernel::CodeBlockMultipleTimer::TimeAccumulator::TimeAccumulator(), toPrettyString(), Mantid::PythonInterface::toString(), Mantid::PythonInterface::toString(), Mantid::Kernel::Strings::toString(), toString(), Mantid::PythonInterface::toString(), Mantid::Kernel::Strings::toString(), toString(), Mantid::Kernel::Strings::toString(), toString(), toString(), Mantid::Kernel::Strings::toString(), Mantid::Kernel::Strings::toString(), toString(), Mantid::API::MultipleFileProperty::value(), Mantid::Kernel::PropertyWithValue< TYPE >::value(), Mantid::API::ExperimentInfo::~ExperimentInfo(), and Mantid::API::MultipleExperimentInfos::~MultipleExperimentInfos().

toString() [5/5]

template<>

std::string Mantid::Kernel::toString

(

PythonObject const &

obj

)

Creates a string representation of the object.

Definition at line 86 of file PythonObjectProperty.cpp.

References Mantid::PythonInterface::isNone(), obj, and toString().

toV3D()

Kernel::V3D Mantid::Kernel::toV3D ( const Eigen::Vector3d &  vec )

inline

This header provides conversion helpers between vector and rotation types in MantidKernel and equivalent types in Eigen.

Author

Simon Heybrock

Date

2017 Converts Eigen::Vector3d to Kernel::V3D

Definition at line 26 of file EigenConversionHelpers.h.

References vec.

Referenced by Mantid::API::applyRectangularDetectorScaleToComponentInfo(), Mantid::Geometry::IndexingUtils::makeCDir(), Mantid::Geometry::Instrument::makeLegacyParameterMap(), Mantid::Geometry::ComponentInfo::position(), Mantid::Geometry::DetectorInfo::position(), Mantid::Geometry::ComponentInfo::position(), Mantid::Geometry::DetectorInfo::position(), Mantid::Geometry::ComponentInfo::relativePosition(), Mantid::Geometry::ComponentInfo::samplePosition(), Mantid::Geometry::DetectorInfo::samplePosition(), Mantid::Geometry::ComponentInfo::scaleFactor(), Mantid::Geometry::ComponentInfo::sourcePosition(), and Mantid::Geometry::DetectorInfo::sourcePosition().

toValue() [1/6]

template<typename T >

void Mantid::Kernel::toValue ( const std::string &  , std::shared_ptr< T > &    )

inline

Definition at line 205 of file PropertyHelper.h.

toValue() [2/6]

template<>

MANTID_KERNEL_DLL void Mantid::Kernel::toValue	(	const std::string &	strValue,
		OptionalBool &	value
	)

Helper functions for setting the value of an OptionalBool property.

Definition at line 14 of file PropertyHelper.cpp.

References Mantid::Kernel::OptionalBool::False, Mantid::Kernel::Strings::toLower(), Mantid::Kernel::OptionalBool::True, and value.

toValue() [3/6]

template<>

void MANTID_KERNEL_DLL Mantid::Kernel::toValue	(	const std::string &	strValue,
		OptionalBool &	value
	)

Helper functions for setting the value of an OptionalBool property.

Definition at line 14 of file PropertyHelper.cpp.

References Mantid::Kernel::OptionalBool::False, Mantid::Kernel::Strings::toLower(), Mantid::Kernel::OptionalBool::True, and value.

toValue() [4/6]

template<typename T >

void Mantid::Kernel::toValue	(	const std::string &	strvalue,
		std::vector< std::vector< T > > &	value,
		const std::string &	outerDelimiter = ",",
		const std::string &	innerDelimiter = "+"
	)

Definition at line 257 of file PropertyHelper.h.

References Mantid::Kernel::StringTokenizer::begin(), Mantid::Kernel::StringTokenizer::count(), Mantid::Kernel::StringTokenizer::end(), Mantid::Kernel::StringTokenizer::TOK_IGNORE_EMPTY, Mantid::Kernel::StringTokenizer::TOK_TRIM, and value.

toValue() [5/6]

template<typename T >

void Mantid::Kernel::toValue	(	const std::string &	strvalue,
		std::vector< T > &	value
	)

Definition at line 252 of file PropertyHelper.h.

References Mantid::Kernel::detail::toValue(), and value.

toValue() [6/6]

template<typename T >

void Mantid::Kernel::toValue ( const std::string &  strvalue, T &  value  )

inline

Definition at line 201 of file PropertyHelper.h.

References value.

Referenced by extractToValueVector(), Mantid::Kernel::PropertyWithValue< TYPE >::getValueForAlias(), Mantid::Kernel::PropertyWithValue< TYPE >::operator=(), Mantid::Kernel::PropertyWithValue< TYPE >::setValue(), and Mantid::API::MultipleFileProperty::setValueAsSingleFile().

toVector3d()

Eigen::Vector3d Mantid::Kernel::toVector3d ( const Kernel::V3D &  vec )

inline

Converts Kernel::V3D to Eigen::Vector3d.

Definition at line 34 of file EigenConversionHelpers.h.

References vec.

Referenced by Mantid::API::applyRectangularDetectorScaleToComponentInfo(), Mantid::Geometry::InstrumentVisitor::commonRegistration(), Mantid::Geometry::IndexingUtils::makeCDir(), Mantid::Geometry::Instrument::makeLegacyParameterMap(), Mantid::Geometry::ComponentInfoBankHelpers::offsetFromAncestor(), Mantid::Geometry::InstrumentVisitor::registerDetector(), Mantid::Geometry::ComponentInfo::scaleComponent(), Mantid::Geometry::ComponentInfo::scaleComponent(), Mantid::Geometry::DetectorInfo::setPosition(), Mantid::Geometry::ComponentInfo::setPosition(), Mantid::Geometry::DetectorInfo::setPosition(), Mantid::Geometry::ComponentInfo::setPosition(), and Mantid::Geometry::ComponentInfo::setScaleFactor().

withinAbsoluteDifference() [1/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinAbsoluteDifference	(	T const	x,
		T const	y,
		S const	tolerance
	)

Test whether x, y are within absolute tolerance tol.

Test whether x, y are within absolute tolerance tol.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 137 of file FloatingPointComparison.cpp.

References tolerance, withinAbsoluteDifference(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Algorithms::He3TubeEfficiency::calculateExponential(), Mantid::DataObjects::TableColumn< Type >::compareVectors(), Mantid::Algorithms::Stitch1D::exec(), Mantid::Crystal::PredictPeaks::exec(), Mantid::Algorithms::DetectorEfficiencyCor::getDetectorGeometry(), Mantid::Algorithms::He3TubeEfficiency::getDetectorGeometry(), Mantid::Algorithms::SampleLogsBehaviour::isWithinTolerance(), Mantid::API::WorkspaceHelpers::matchingBins(), Mantid::Algorithms::FitOneSinglePeak::processNStoreFitResult(), Mantid::Algorithms::UnwrapMonitor::unwrapX(), withinAbsoluteDifference(), and Mantid::Algorithms::CompareWorkspaces::withinAbsoluteTolerance().

withinAbsoluteDifference() [2/6]

template<typename T , typename S >

bool Mantid::Kernel::withinAbsoluteDifference	(	T const	x,
		T const	y,
		S const	tolerance
	)

Compare floating point numbers for absolute difference to within the given tolerance.

Test whether x, y are within absolute tolerance tol.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 137 of file FloatingPointComparison.cpp.

References tolerance, withinAbsoluteDifference(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Algorithms::He3TubeEfficiency::calculateExponential(), Mantid::DataObjects::TableColumn< Type >::compareVectors(), Mantid::Algorithms::Stitch1D::exec(), Mantid::Crystal::PredictPeaks::exec(), Mantid::Algorithms::DetectorEfficiencyCor::getDetectorGeometry(), Mantid::Algorithms::He3TubeEfficiency::getDetectorGeometry(), Mantid::Algorithms::SampleLogsBehaviour::isWithinTolerance(), Mantid::API::WorkspaceHelpers::matchingBins(), Mantid::Algorithms::FitOneSinglePeak::processNStoreFitResult(), Mantid::Algorithms::UnwrapMonitor::unwrapX(), withinAbsoluteDifference(), and Mantid::Algorithms::CompareWorkspaces::withinAbsoluteTolerance().

withinAbsoluteDifference() [3/6]

template<typename T , typename S >

bool Mantid::Kernel::withinAbsoluteDifference ( T const  x, T const  y, S const  tolerance, MADE_FOR_FLOATS    )

inline

Compare floating point numbers for absolute difference to within the given tolerance.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 164 of file FloatingPointComparison.cpp.

References ltEquals(), tolerance, Mantid::Geometry::x, and Mantid::Geometry::y.

withinAbsoluteDifference() [4/6]

template<typename T , typename S >

bool Mantid::Kernel::withinAbsoluteDifference ( T const  x, T const  y, S const  tolerance, MADE_FOR_INTEGERS    )

inline

Definition at line 147 of file FloatingPointComparison.cpp.

References ltEquals(), tolerance, Mantid::Geometry::x, and Mantid::Geometry::y.

withinAbsoluteDifference() [5/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinAbsoluteDifference	(	T const	x,
		T const	y,
		S const	tolerance,
		std::false_type
	)

withinAbsoluteDifference() [6/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinAbsoluteDifference	(	T const	x,
		T const	y,
		S const	tolerance,
		std::true_type
	)

withinAbsoluteDifference< V3D, double >()

template<>

DLLExport bool Mantid::Kernel::withinAbsoluteDifference< V3D, double >	(	V3D const	V1,
		V3D const	V2,
		double const	tolerance
	)

Template specialization for V3D.

Compare 3D vectors (class V3D) for absolute difference to within the given tolerance. The ansolute difference is calculated as abs diff = ||V1 - V2|| consistent with other normalized vector binary operations.

Parameters

V1	:: first value
V2	:: second value
tolerance	:: the tolerance

Returns

True if the vectorsare considered equal within the given tolerance, false otherwise. False if any value in either vector is an NaN.

Definition at line 302 of file FloatingPointComparison.cpp.

References ltEquals(), and tolerance.

withinRelativeDifference() [1/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinRelativeDifference	(	T const	x,
		T const	y,
		S const	tolerance
	)

Test whether x, y are within relative tolerance tol.

Test whether x, y are within relative tolerance tol.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 181 of file FloatingPointComparison.cpp.

References tolerance, withinRelativeDifference(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Crystal::FindSXPeaksHelper::SXPeak::compare(), Mantid::DataObjects::TableColumn< Type >::compareVectorsRelError(), ComponentCreationHelper::double_cmprsn(), Mantid::API::WorkspaceHelpers::matchingBins(), withinRelativeDifference(), and Mantid::Algorithms::CompareWorkspaces::withinRelativeTolerance().

withinRelativeDifference() [2/6]

template<typename T , typename S >

bool Mantid::Kernel::withinRelativeDifference	(	T const	x,
		T const	y,
		S const	tolerance
	)

Compare floating point numbers for relative difference to within the given tolerance.

Test whether x, y are within relative tolerance tol.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 181 of file FloatingPointComparison.cpp.

References tolerance, withinRelativeDifference(), Mantid::Geometry::x, and Mantid::Geometry::y.

Referenced by Mantid::Crystal::FindSXPeaksHelper::SXPeak::compare(), Mantid::DataObjects::TableColumn< Type >::compareVectorsRelError(), ComponentCreationHelper::double_cmprsn(), Mantid::API::WorkspaceHelpers::matchingBins(), withinRelativeDifference(), and Mantid::Algorithms::CompareWorkspaces::withinRelativeTolerance().

withinRelativeDifference() [3/6]

template<typename T , typename S >

bool Mantid::Kernel::withinRelativeDifference ( T const  x, T const  y, S const  tolerance, MADE_FOR_FLOATS    )

inline

Compare floating point numbers for relative difference to within the given tolerance.

Parameters

x	:: first value
y	:: second value
tolerance	:: the tolerance

Returns

True if the numbers are considered equal within the given tolerance, false otherwise. False if either value is NaN.

Definition at line 213 of file FloatingPointComparison.cpp.

References ltEquals(), tolerance, Mantid::Geometry::x, and Mantid::Geometry::y.

withinRelativeDifference() [4/6]

template<typename T , typename S >

bool Mantid::Kernel::withinRelativeDifference ( T const  x, T const  y, S const  tolerance, MADE_FOR_INTEGERS    )

inline

Definition at line 190 of file FloatingPointComparison.cpp.

References tolerance, Mantid::Geometry::x, and Mantid::Geometry::y.

withinRelativeDifference() [5/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinRelativeDifference ( T const  x, T const  y, S const  tolerance, std::false_type    )

inline

withinRelativeDifference() [6/6]

template<typename T , typename S = T>

MANTID_KERNEL_DLL bool Mantid::Kernel::withinRelativeDifference ( T const  x, T const  y, S const  tolerance, std::true_type    )

inline

withinRelativeDifference< V3D, double >()

template<>

DLLExport bool Mantid::Kernel::withinRelativeDifference< V3D, double >	(	V3D const	V1,
		V3D const	V2,
		double const	tolerance
	)

Compare 3D vectors (class V3D) for relative difference to within the given tolerance.

The relative difference is calculated as rel diff = ||V1 - V2||/sqrt(||V1||*||V2||) consistent with other normalized vector binary operations.

Parameters

V1	:: first value
V2	:: second value
tolerance	:: the tolerance

Returns

True if the vectorsare considered equal within the given tolerance, false otherwise. False if any value in either vector is an NaN.

Definition at line 319 of file FloatingPointComparison.cpp.

References ltEquals(), Mantid::Kernel::V3D::norm(), Mantid::Kernel::V3D::norm2(), tolerance, Mantid::Kernel::V3D::X(), Mantid::Kernel::V3D::Y(), and Mantid::Kernel::V3D::Z().

Variable Documentation

CubicSpline< double, double >

EXTERN_MANTID_KERNEL template class MANTID_KERNEL_DLL Mantid::Kernel::CubicSpline< double, double >

Definition at line 12 of file Spline.cpp.

DEFAULT_BLOCK_SIZE

constexpr size_t Mantid::Kernel::DEFAULT_BLOCK_SIZE {100000}

constexpr

Default number of items to read in from any of the files.

Definition at line 21 of file BinaryFile.h.

Referenced by Mantid::Kernel::BinaryFile< T >::getBufferSize(), and Mantid::DataHandling::LoadEventPreNexus2::procEvents().

g_log

Kernel::Logger Mantid::Kernel::g_log("UsageServiceImpl")

(

"UsageServiceImpl"

)

static logger

LIB_PREFIX

const std::string Mantid::Kernel::LIB_PREFIX = "lib"

Definition at line 74 of file DllOpen.cpp.

Referenced by Mantid::Kernel::DllOpen::isValidFilename().

LinearSpline< double, double >

EXTERN_MANTID_KERNEL template class MANTID_KERNEL_DLL Mantid::Kernel::LinearSpline< double, double >

Definition at line 13 of file Spline.cpp.

MAX_BLOCK_SIZE

constexpr size_t Mantid::Kernel::MAX_BLOCK_SIZE {100000000}

constexpr

Max size block to read from a file (memory limitations)

Definition at line 24 of file BinaryFile.h.

MIN_BLOCK_SIZE

constexpr size_t Mantid::Kernel::MIN_BLOCK_SIZE {1000}

constexpr

Min size of a block (too small is inefficient)

Definition at line 27 of file BinaryFile.h.

PropertyWithValue< PythonObject >

template class MANTID_PYTHONINTERFACE_CORE_DLL Mantid::Kernel::PropertyWithValue< PythonObject >

NOTE: For Linux builds (and maybe Windows), it is necessary that the below DLL export occur here.

This declaration normally lives in Framework/Kernel/PropertyWithValue.cpp. However, because the boost library is not linked in Kernel, this declaration can only occur inside the PythonInterface layer For Linux builds, this MUST be instantiated BEFORE the declaration of PythonObjectProperty Exception: Linux with clang needs this in the source file instead

Definition at line 37 of file PythonObjectProperty.h.

Tolerance

constexpr double Mantid::Kernel::Tolerance = 1.0e-06

constexpr

Standard tolerance value.

Definition at line 12 of file Tolerance.h.

Referenced by Mantid::Kernel::V3D::azimuth_polar_SNS(), Mantid::Geometry::Track::buildLink(), Mantid::Geometry::MeshObject::calcValidType(), Mantid::Geometry::CSGObject::checkSurfaceValid(), Mantid::Kernel::V3D::coLinear(), Mantid::Algorithms::CompareWorkspaces::compareEventWorkspaces(), Mantid::Geometry::Cone::distance(), Mantid::Geometry::Quadratic::distance(), Mantid::Geometry::Torus::distance(), Mantid::Geometry::BoundingBox::doesLineIntersect(), Mantid::Kernel::Matrix< T >::equals(), Mantid::Crystal::CombinePeaksWorkspaces::exec(), Mantid::Crystal::DiffPeaksWorkspaces::exec(), Mantid::Crystal::GoniometerAnglesFromPhiRotation::exec(), Mantid::Geometry::DetectorGroup::getPos(), MantidQt::MantidWidgets::FindPeakDefaultStrategy::initialise(), Mantid::Geometry::Line::intersect(), Mantid::API::PanelsSurfaceCalculator::isBankFlat(), Mantid::Geometry::BoundingBox::isPointInside(), Mantid::Geometry::Line::isValid(), Mantid::Geometry::Line::lambdaPair(), Mantid::Geometry::Track::nonComplete(), Mantid::Geometry::Cylinder::onSurface(), Mantid::Geometry::Quadratic::onSurface(), Mantid::Geometry::Sphere::onSurface(), Mantid::Geometry::Cone::onSurface(), Mantid::Geometry::IntersectionPoint::operator<(), Mantid::Geometry::Cone::operator==(), Mantid::Geometry::IntersectionPoint::operator==(), Mantid::Kernel::Quat::operator==(), Mantid::Geometry::detail::ShapeInfo::operator==(), Mantid::Geometry::Torus::operator==(), Mantid::Kernel::V3D::operator==(), Mantid::Kernel::VMDBase< TYPE >::operator==(), Mantid::Geometry::Plane::planeType(), Mantid::Geometry::Cone::setNorm(), Mantid::Geometry::Torus::setNorm(), Mantid::Geometry::Cylinder::setNormVec(), Mantid::Geometry::Plane::setSurface(), Mantid::MDAlgorithms::MDWSTransform::setUVvectors(), Mantid::Geometry::Cylinder::side(), Mantid::Geometry::Plane::side(), Mantid::Geometry::Quadratic::side(), Mantid::Geometry::Sphere::side(), Mantid::Geometry::Cone::side(), Mantid::Kernel::V3D::spherical_rad(), Mantid::Geometry::Cone::write(), Mantid::Geometry::Cylinder::write(), Mantid::Geometry::Sphere::write(), and Mantid::Geometry::Torus::write().