Basic Function class. More...

#include <Function.h>

Inheritance diagram for lsst.afw.math::Function< ReturnT >:

Public Member Functions
	Function (unsigned int nParams)
	Construct a Function given the number of function parameters. More...

	Function (std::vector< double > const &params)
	Construct a Function given the function parameters. More...

virtual	~Function ()

unsigned int	getNParameters () const
	Return the number of function parameters. More...

virtual double	getParameter (unsigned int ind) const
	Get one function parameter without range checking. More...

std::vector< double > const &	getParameters () const
	Return all function parameters. More...

virtual bool	isLinearCombination () const
	Is the function a linear combination of its parameters? More...

void	setParameter (unsigned int ind, double newValue)
	Set one function parameter without range checking. More...

void	setParameters (std::vector< double > const &params)
	Set all function parameters. More...

virtual std::string	toString (std::string const &) const
	Return a string representation of the function. More...

Public Member Functions inherited from lsst::daf::base::Citizen
	Citizen (const std::type_info &)

	Citizen (Citizen const &)

	~Citizen ()

Citizen &	operator= (Citizen const &)

std::string	repr () const
	Return a string representation of a Citizen. More...

void	markPersistent (void)
	Mark a Citizen as persistent and not destroyed until process end. More...

memId	getId () const
	Return the Citizen's ID. More...

Public Member Functions inherited from lsst.afw.table.io::Persistable
void	writeFits (std::string const &fileName, std::string const &mode="w") const
	Write the object to a regular FITS file. More...

void	writeFits (fits::MemFileManager &manager, std::string const &mode="w") const
	Write the object to a FITS image in memory. More...

void	writeFits (fits::Fits &fitsfile) const
	Write the object to an already-open FITS object. More...

virtual bool	isPersistable () const
	Return true if this particular object can be persisted using afw::table::io. More...

virtual	~Persistable ()

Protected Member Functions
virtual std::string	getPythonModule () const
	Return the fully-qualified Python module that should be imported to guarantee that its factory is registered. More...

	Function ()

Protected Member Functions inherited from lsst.afw.table.io::Persistable
virtual std::string	getPersistenceName () const
	Return the unique name used to persist this object and look up its factory. More...

virtual void	write (OutputArchiveHandle &handle) const
	Write the object to one or more catalogs. More...

	Persistable ()

	Persistable (Persistable const &other)

void	operator= (Persistable const &other)

Protected Attributes
std::vector< double >	_params

bool	_isCacheValid

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, unsigned int const version)

Friends
class	boost::serialization::access

Additional Inherited Members
Public Types inherited from lsst::daf::base::Citizen
enum	{ magicSentinel = 0xdeadbeef }

typedef unsigned long	memId
	Type of the block's ID. More...

typedef memId(*	memNewCallback )(const memId cid)
	A function used to register a callback. More...

typedef memId(*	memCallback )(const Citizen *ptr)

Static Public Member Functions inherited from lsst::daf::base::Citizen
static bool	hasBeenCorrupted ()
	Check all allocated blocks for corruption. More...

static memId	getNextMemId ()
	Return the memId of the next object to be allocated. More...

static int	init ()
	Called once when the memory system is being initialised. More...

static int	census (int, memId startingMemId=0)
	How many active Citizens are there? More...

static void	census (std::ostream &stream, memId startingMemId=0)
	Print a list of all active Citizens to stream, sorted by ID. More...

static const std::vector < const Citizen * > *	census ()
	Return a (newly allocated) std::vector of active Citizens sorted by ID. More...

static memId	setNewCallbackId (memId id)
	Call the NewCallback when block is allocated. More...

static memId	setDeleteCallbackId (memId id)
	Call the current DeleteCallback when block is deleted. More...

static memNewCallback	setNewCallback (memNewCallback func)
	Set the NewCallback function. More...

static memCallback	setDeleteCallback (memCallback func)
	Set the DeleteCallback function. More...

static memCallback	setCorruptionCallback (memCallback func)
	Set the CorruptionCallback function. More...

Static Public Member Functions inherited from lsst.afw.table.io::PersistableFacade< Function< ReturnT > >
static boost::shared_ptr < Function< ReturnT > >	readFits (fits::Fits &fitsfile)
	Read an object from an already open FITS object. More...

static boost::shared_ptr < Function< ReturnT > >	readFits (std::string const &fileName, int hdu=0)
	Read an object from a regular FITS file. More...

static boost::shared_ptr < Function< ReturnT > >	readFits (fits::MemFileManager &manager, int hdu=0)
	Read an object from a FITS file in memory. More...

Protected Types inherited from lsst.afw.table.io::Persistable
typedef io::OutputArchiveHandle	OutputArchiveHandle

Detailed Description

template<typename ReturnT>
class lsst.afw.math::Function< ReturnT >

Basic Function class.

Function objects are functions whose parameters may be read and changed using getParameters and setParameters. They were designed for use with the Kernel class.

These are simple functors with the restrictions that:

Function arguments and parameters are double precision
The return type is templated

To create a function for a particular equation, subclass Function or (much more likely) Function1 or Function2. Your subclass must:

Have one or more constructors, all of which must initialize _params
Define operator() with code to compute the function using this->_params or this->getParams() to reference the parameters
If the function is a linear combination of parameters then override the function isLinearCombination.

If you wish to cache any information you may use the _isCacheValid flag; this is automatically set false whenever parameters are changed.

Design Notes: The reason these functions exist (rather than using a pre-existing function class, such as Functor in VisualWorkbench) is because the Kernel class requires function objects with a standard interface for setting and getting function parameters.

The reason isLinearCombination exists is to support refactoring LinearCombinationKernels.

Definition at line 89 of file Function.h.

Constructor & Destructor Documentation

template<typename ReturnT>

lsst.afw.math::Function< ReturnT >::Function ( unsigned int nParams )

inlineexplicit

Construct a Function given the number of function parameters.

The function parameters are initialized to 0.

Parameters

nParams number of function parameters

Definition at line 99 of file Function.h.

         :
             lsst::daf::base::Citizen(typeid(this)),
             _params(nParams),
             _isCacheValid(false)
         {}

template<typename ReturnT>

lsst.afw.math::Function< ReturnT >::Function ( std::vector< double > const & params )

inlineexplicit

Construct a Function given the function parameters.

Parameters

params function parameters

Definition at line 110 of file Function.h.

         :
             lsst::daf::base::Citizen(typeid(this)),
             _params(params),
             _isCacheValid(false)
         {}

template<typename ReturnT>

virtual lsst.afw.math::Function< ReturnT >::~Function ( )

inlinevirtual

Definition at line 118 of file Function.h.

118 {}

template<typename ReturnT>

lsst.afw.math::Function< ReturnT >::Function ( )

inlineexplicitprotected

Definition at line 210 of file Function.h.

210 : lsst::daf::base::Citizen(typeid(this)), _params(0), _isCacheValid(false) {}

lsst.afw.math::Function::_isCacheValid

bool _isCacheValid

Definition: Function.h:205

lsst.afw.math::Function::_params

std::vector< double > _params

Definition: Function.h:204

lsst::daf::base::Citizen

Citizen is a class that should be among all LSST classes base classes, and handles basic memory manag...

Definition: Citizen.h:56

Member Function Documentation

template<typename ReturnT>

unsigned int lsst.afw.math::Function< ReturnT >::getNParameters ( ) const

inline

Return the number of function parameters.

Returns: the number of function parameters

Definition at line 125 of file Function.h.

                                             {
             return _params.size();
         }

template<typename ReturnT>

virtual double lsst.afw.math::Function< ReturnT >::getParameter ( unsigned int ind ) const

inlinevirtual

Get one function parameter without range checking.

Returns: the specified function parameter

Parameters

ind	index of parameter

Definition at line 134 of file Function.h.

               {
             return _params[ind];
         }

template<typename ReturnT>

std::vector<double> const& lsst.afw.math::Function< ReturnT >::getParameters ( ) const

inline

Return all function parameters.

Returns: the function parameters as a vector

Definition at line 145 of file Function.h.

                                                        {
             return _params;
         }

template<typename ReturnT>

virtual std::string lsst.afw.math::Function< ReturnT >::getPythonModule ( ) const

inlineprotectedvirtual

Return the fully-qualified Python module that should be imported to guarantee that its factory is registered.

Must be less than ArchiveIndexSchema::MAX_MODULE_LENGTH characters.

Will be ignored if empty.

Reimplemented from lsst.afw.table.io::Persistable.

Definition at line 207 of file Function.h.

207 { return "lsst.afw.math"; }

template<typename ReturnT>

virtual bool lsst.afw.math::Function< ReturnT >::isLinearCombination ( ) const

inlinevirtual

Is the function a linear combination of its parameters?

Returns: true if the function can be expressed as: sum over i of parameter_i * function_i(args)

Warning: : subclasses must override if true.

Reimplemented in lsst.afw.math::Chebyshev1Function1< ReturnT >, lsst.afw.math::PolynomialFunction1< ReturnT >, and lsst.afw.math::BasePolynomialFunction2< ReturnT >.

Definition at line 156 of file Function.h.

156 { return false; }

template<typename ReturnT>

template<class Archive >

void lsst.afw.math::Function< ReturnT >::serialize	(	Archive &	ar,
		unsigned int const	version
	)

inlineprivate

Definition at line 215 of file Function.h.

                                                                 {
             ar & make_nvp("params", _params);
         }

template<typename ReturnT>

void lsst.afw.math::Function< ReturnT >::setParameter	(	unsigned int	ind,
		double	newValue
	)

inline

Set one function parameter without range checking.

Parameters

ind	index of parameter
newValue	new value for parameter

Definition at line 161 of file Function.h.

         {
             _isCacheValid = false;
             _params[ind] = newValue;
         }

template<typename ReturnT>

void lsst.afw.math::Function< ReturnT >::setParameters ( std::vector< double > const & params )

inline

Set all function parameters.

Exceptions

lsst::pex::exceptions::InvalidParameterError if the wrong number of parameters is supplied.

Parameters

params vector of function parameters

Definition at line 175 of file Function.h.

         {
             if (_params.size() != params.size()) {
                 throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                     (boost::format("params has %d entries instead of %d") % \
                     params.size() % _params.size()).str());
             }
             _isCacheValid = false;
             _params = params;
         }

template<typename ReturnT>

virtual std::string lsst.afw.math::Function< ReturnT >::toString ( std::string const & ) const

inlinevirtual

Return a string representation of the function.

Returns: a string representation of the function

Definition at line 192 of file Function.h.

                                                            {
             std::stringstream os;
             os << "parameters: [ ";
             for (std::vector<double>::const_iterator i = _params.begin(); i != _params.end(); ++i) {
                 if (i != _params.begin()) os << ", ";
                 os << *i;
             }
             os << " ]";
             return os.str();
         }

Friends And Related Function Documentation

template<typename ReturnT>

friend class boost::serialization::access

friend

Definition at line 213 of file Function.h.

Member Data Documentation

template<typename ReturnT>

bool lsst.afw.math::Function< ReturnT >::_isCacheValid

mutableprotected

Definition at line 205 of file Function.h.

template<typename ReturnT>

std::vector<double> lsst.afw.math::Function< ReturnT >::_params

protected

Definition at line 204 of file Function.h.

The documentation for this class was generated from the following file:

/home/lsstsw/stack/Linux64/afw/11.0.rc2+4/include/lsst/afw/math/Function.h

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

template<typename ReturnT> class lsst.afw.math::Function< ReturnT >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename ReturnT>
class lsst.afw.math::Function< ReturnT >