lsst::meas::algorithms::shapelet::Polynomial2D Class Reference

#include <Function2D.h>

Inheritance diagram for lsst::meas::algorithms::shapelet::Polynomial2D:

Public Member Functions
	Polynomial2D (double scale=1.)
	Polynomial2D (const Polynomial2D &rhs)
	Polynomial2D (const DMatrix &a, double scale=1.)
	Polynomial2D (std::istream &fin)
	Polynomial2D (int xo, int yo, double scale=1.)
virtual	~Polynomial2D ()
virtual void	write (std::ostream &fout) const
virtual std::auto_ptr< Function2D >	dFdX () const
virtual std::auto_ptr< Function2D >	dFdY () const
std::auto_ptr< Function2D >	copy () const
virtual void	addLinear (double a, double b, double c)
virtual void	linearPreTransform (double a, double b, double c, double d, double e, double f)
virtual void	operator+= (const Function2D &rhs)
void	makeProductOf (const Polynomial2D &f, const Polynomial2D &g)
virtual void	setFunction (int xOrder, int yOrder, const DVector &fVect)
Public Member Functions inherited from lsst::meas::algorithms::shapelet::Function2D
	Function2D ()
	Function2D (int xo, int yo)
	Function2D (int xo, int yo, const DMatrix &c)
	Function2D (const Function2D &rhs)
virtual	~Function2D ()
virtual std::auto_ptr< Function2D >	conj () const
virtual void	operator*= (double scale)
virtual double	operator() (double x, double y) const
double	operator() (const Position &p) const
virtual void	setTo (double value)
bool	isNonZero () const
int	getXOrder () const
int	getYOrder () const
const DMatrix &	getCoeffs () const
virtual void	simpleFit (int order, const std::vector< Position > &pos, const std::vector< double > &v, const std::vector< bool > &shouldUse, const std::vector< double > *sigList=0, double *chisqOut=0, int *dofOut=0, DMatrix *cov=0)
virtual void	outlierFit (int order, double nsig, const std::vector< Position > &pos, const std::vector< double > &v, std::vector< bool > *shouldUse, const std::vector< double > *sigList=0, double *chisqout=0, int *dofout=0, DMatrix *cov=0)
virtual void	orderFit (int maxOrder, double equivProb, const std::vector< Position > &pos, const std::vector< double > &v, const std::vector< bool > &shouldUse, const std::vector< double > *sigList=0, double *chisqout=0, int *dofout=0, DMatrix *cov=0)
virtual void	linearTransform (double a, double b, double c, const Function2D &f, const Function2D &g)
virtual void	linearTransform (double a, double b, const Function2D &f)

Private Member Functions
virtual DVector	definePX (int order, double x) const
virtual DVector	definePY (int order, double y) const

Private Attributes
double	_scale

Additional Inherited Members
Static Public Member Functions inherited from lsst::meas::algorithms::shapelet::Function2D
static std::auto_ptr< Function2D >	read (std::istream &fin)
Protected Attributes inherited from lsst::meas::algorithms::shapelet::Function2D
int	_xOrder
int	_yOrder
std::auto_ptr< DMatrix >	_coeffs

Detailed Description

Definition at line 234 of file Function2D.h.

Constructor & Destructor Documentation

lsst::meas::algorithms::shapelet::Polynomial2D::Polynomial2D ( double  scale = 1. )

inline

Definition at line 239 of file Function2D.h.

: Function2D(),_scale(scale) {}

lsst::meas::algorithms::shapelet::Polynomial2D::Polynomial2D ( const Polynomial2D &  rhs )

inline

Definition at line 241 of file Function2D.h.

                                              :
            Function2D(rhs),_scale(rhs._scale) {}

lsst::meas::algorithms::shapelet::Polynomial2D::Polynomial2D ( const DMatrix &  a, double  scale = 1.  )

inline

Definition at line 244 of file Function2D.h.

                                                        : 
            Function2D(a.TMV_colsize()-1,a.TMV_rowsize()-1,a), _scale(scale) {}

lsst::meas::algorithms::shapelet::Polynomial2D::Polynomial2D

(

std::istream &

fin

)

Definition at line 90 of file Function2D.cc.

                                              : 
        Function2D()
    {
        // Order of parameters:  (example is for xorder = 2, yorder = 3
        // xorder(2) yorder(3) a00 a10 a01 a20 a11 a02 a21 a12 a03
        // where f = a00 + a10 x + a01 y + a20 x^2 + a11 xy + a02 y^2
        //           + a21 x^2 y + a12 xy^2 + a03 y^3
        // Note that total order doesn't go past the max of xorder and yorder.
        // Also note that a30 is not listed since xorder is only 2.
        // Note that aij are complex numbers so each is listed as 
        // real_part imag_part.
        int xo,yo;
        if (!(fin >> xo >> yo >> _scale)) 
            throw std::runtime_error("reading xorder,yorder,scale");
        _xOrder = xo;
        _yOrder = yo;
        _coeffs.reset(new DMatrix(xo+1,yo+1));
        _coeffs->setZero();
        int maxOrder = std::max(xo,yo);
        for(int m=0;m<=maxOrder;++m) {
            int i0 = std::min(xo,m);
            int len = std::min(yo,i0)+1;
#ifdef USE_TMV
            DVectorView coeffDiag = _coeffs->subVector(i0,m-i0,-1,1,len);
            for(int i=0;i<len;++i) fin >> coeffDiag(i);
#else
            for(int i=0;i<len;++i) fin >> (*_coeffs)(i0-i,m-i0+i);
#endif
        }
        if (!fin) throw std::runtime_error("reading (polynomial)");
    }

lsst::meas::algorithms::shapelet::Polynomial2D::Polynomial2D ( int  xo, int  yo, double  scale = 1.  )

inline

Definition at line 249 of file Function2D.h.

                                                    :
            Function2D(xo,yo), _scale(scale) {}

virtual lsst::meas::algorithms::shapelet::Polynomial2D::~Polynomial2D ( )

inlinevirtual

Definition at line 252 of file Function2D.h.

{}

Member Function Documentation

void lsst::meas::algorithms::shapelet::Polynomial2D::addLinear ( double  a, double  b, double  c  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 149 of file Function2D.cc.

    {
        (*_coeffs)(0,0) += a;
        (*_coeffs)(1,0) += b*_scale;
        (*_coeffs)(0,1) += c*_scale;
    }

std::auto_ptr<Function2D> lsst::meas::algorithms::shapelet::Polynomial2D::copy ( ) const

inlinevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 260 of file Function2D.h.

        { return std::auto_ptr<Function2D>(new Polynomial2D(*this)); }

virtual DVector lsst::meas::algorithms::shapelet::Polynomial2D::definePX ( int  order, double  x  ) const

inlineprivatevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 279 of file Function2D.h.

        {
            DVector temp(order+1);
            temp(0) = 1.0;
            for(int i=1;i<=order;++i) temp(i) = temp(i-1)*x/_scale;
            return temp;
        }

virtual DVector lsst::meas::algorithms::shapelet::Polynomial2D::definePY ( int  order, double  y  ) const

inlineprivatevirtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 286 of file Function2D.h.

        { return definePX(order,y); }

std::auto_ptr< Function2D > lsst::meas::algorithms::shapelet::Polynomial2D::dFdX ( ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 260 of file Function2D.cc.

    {
        if (_xOrder == 0) {
            return std::auto_ptr<Function2D>(new Constant2D());
        }
        if (_xOrder == 1 && _yOrder == 0) {
            return std::auto_ptr<Function2D>(
                new Constant2D((*_coeffs)(1,0)));
        }

        int newXOrder = _xOrder-1;
        int newYOrder = _xOrder > _yOrder ? _yOrder : _yOrder-1;

        std::auto_ptr<Polynomial2D> temp(
            new Polynomial2D(newXOrder,newYOrder));

        int maxOrder = std::max(newXOrder,newYOrder);
        for(int i=newXOrder;i>=0;--i) {
            for(int j=std::min(maxOrder-i,newYOrder);j>=0;--j) {
                Assert(i+1<=_xOrder);
                Assert(j<=_yOrder);
                Assert(i+1+j<=std::max(_xOrder,_yOrder));
                (*temp->_coeffs)(i,j) = (*_coeffs)(i+1,j)*(i+1.)/_scale;
            }
        }
        return std::auto_ptr<Function2D>(temp);
    }

std::auto_ptr< Function2D > lsst::meas::algorithms::shapelet::Polynomial2D::dFdY ( ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 288 of file Function2D.cc.

    {
        if (_yOrder == 0) {
            return std::auto_ptr<Function2D>(new Constant2D());
        }
        if (_yOrder == 1 && _xOrder == 0) {
            return std::auto_ptr<Function2D>(
                new Constant2D((*_coeffs)(0,1)));
        }

        int newXOrder = _yOrder > _xOrder ? _xOrder : _xOrder-1;
        int newYOrder = _yOrder-1;

        std::auto_ptr<Polynomial2D> temp(
            new Polynomial2D(newXOrder,newYOrder));

        int maxOrder = std::max(newXOrder,newYOrder);
        for(int i=newXOrder;i>=0;--i) 
            for(int j=std::min(maxOrder-i,newYOrder);j>=0;--j) {
                Assert(i<=_xOrder);
                Assert(j+1<=_yOrder);
                Assert(i+j+1<=std::max(_xOrder,_yOrder));
                (*temp->_coeffs)(i,j) = (*_coeffs)(i,j+1)*(j+1.)/_scale;
            }
        return std::auto_ptr<Function2D>(temp);
    }

void lsst::meas::algorithms::shapelet::Polynomial2D::linearPreTransform ( double  a, double  b, double  c, double  d, double  e, double  f  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 156 of file Function2D.cc.

    {
        // F(x,y) = Sum_i,j a(i,j) x^i y^j
        // F'(x,y) = F(a+bx+cy,d+ex+fy)
        //         = Sum_i,j a(i,j) (a+bx+cy)^i (d+ex+fy)^j
        //         = Sum_i,j a(i,j) (Sum_kl iCk kCl a^i-k (bx)^k-l (cy)^l) *
        //                Sum_mn jCm mCn d^j-m (ex)^m-n (fy)^n
        int maxOrder = std::max(_xOrder,_yOrder);
        std::vector<double> scaleToThe(maxOrder+1);
        scaleToThe[0] = 1.0; scaleToThe[1] = _scale;
        for(int i=2;i<=maxOrder;++i) scaleToThe[i] = scaleToThe[i-1]*_scale;
        std::vector<double> aToThe(maxOrder+1);
        std::vector<double> bToThe(maxOrder+1);
        std::vector<double> cToThe(maxOrder+1);
        std::vector<double> dToThe(maxOrder+1);
        std::vector<double> eToThe(maxOrder+1);
        std::vector<double> fToThe(maxOrder+1);
        aToThe[0] = 1.; aToThe[1] = a;
        bToThe[0] = 1.; bToThe[1] = b;
        cToThe[0] = 1.; cToThe[1] = c;
        dToThe[0] = 1.; dToThe[1] = d;
        eToThe[0] = 1.; eToThe[1] = e;
        fToThe[0] = 1.; fToThe[1] = f;
        for(int i=2;i<=maxOrder;++i) aToThe[i] = aToThe[i-1]*a;
        for(int i=2;i<=maxOrder;++i) bToThe[i] = bToThe[i-1]*b;
        for(int i=2;i<=maxOrder;++i) cToThe[i] = cToThe[i-1]*c;
        for(int i=2;i<=maxOrder;++i) dToThe[i] = dToThe[i-1]*d;
        for(int i=2;i<=maxOrder;++i) eToThe[i] = eToThe[i-1]*e;
        for(int i=2;i<=maxOrder;++i) fToThe[i] = fToThe[i-1]*f;
        _xOrder = maxOrder; _yOrder = maxOrder;

        DMatrix binom(maxOrder+1,maxOrder+1);
        binom(0,0) = 1.0;
        for(int n=1;n<=maxOrder;++n) {
            binom(n,0) = 1.0;
            binom(n,n) = 1.0;
            for(int m=1;m<n;++m) {
                binom(n,m) = binom(n-1,m-1) + binom(n-1,m);
            }
        }

        std::auto_ptr<DMatrix> oldCoeffs = _coeffs;
        _coeffs.reset(new DMatrix(_xOrder+1,_yOrder+1));
        _coeffs->setZero();
        for(int i=0;i<=_xOrder;++i) for(int j=0;j<=_yOrder&&i+j<=maxOrder;++j) {
            for(int k=0;k<=i;++k) for(int l=0;l<=k;++l) {
                for(int m=0;m<=j;++m) for(int n=0;n<=m;++n) {
                    (*_coeffs)(k-l+m-n,l+n) += 
                        binom(i,k)*binom(k,l)*binom(j,m)*binom(m,n)*
                        aToThe[i-k]*bToThe[k-l]*cToThe[l]*
                        dToThe[j-m]*eToThe[m-n]*fToThe[n]*
                        (*oldCoeffs)(i,j)/scaleToThe[i+j-k-m];
                }
            }
        }
    }

void lsst::meas::algorithms::shapelet::Polynomial2D::makeProductOf	(	const Polynomial2D &	f,
		const Polynomial2D &	g
	)

Definition at line 236 of file Function2D.cc.

    {
        // h(x,y) = f(x,y) * g(x,y)
        //        = (Sum_ij f_ij x^i y^j) (Sum_mn g_mn x^m y^n)
        //        = Sum_ijmj f_ij g_mn x^(i+m) y^(j+n)
        Assert(_scale == f._scale);
        Assert(_scale == g._scale);
        int newXOrder = f.getXOrder() + g.getXOrder();
        int newYOrder = f.getYOrder() + g.getYOrder();
        if (_xOrder != newXOrder || _yOrder != newYOrder) {
            _xOrder = newXOrder;
            _yOrder = newYOrder;
            _coeffs.reset(new DMatrix(_xOrder+1,_yOrder+1));
        }
        _coeffs->setZero();
        for(int i=0;i<=f.getXOrder();++i) for(int j=0;j<=f.getYOrder();++j) {
            for(int m=0;m<=g.getXOrder();++m) for(int n=0;n<=g.getYOrder();++n) {
                Assert (i+m <= _xOrder && j+n <= _yOrder);
                (*_coeffs)(i+m,j+n) += (*f._coeffs)(i,j) * (*g._coeffs)(m,n);
            }
        }
    }

void lsst::meas::algorithms::shapelet::Polynomial2D::operator+= ( const Function2D &  rhs )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 214 of file Function2D.cc.

    {
        const Polynomial2D* prhs = dynamic_cast<const Polynomial2D*>(&rhs);
        Assert(prhs);
        Assert(_scale == prhs->_scale);
        if (_xOrder == prhs->_xOrder && _yOrder == prhs->_yOrder) {
            *_coeffs += *prhs->_coeffs;
        } else {
            int newXOrder = std::max(_xOrder,prhs->_xOrder);
            int newYOrder = std::max(_yOrder,prhs->_yOrder);
            std::auto_ptr<DMatrix > newCoeffs(
                new DMatrix(newXOrder+1,newYOrder+1));
            newCoeffs->setZero();
            newCoeffs->TMV_subMatrix(0,_xOrder+1,0,_yOrder+1) = *_coeffs;
            newCoeffs->TMV_subMatrix(0,prhs->_xOrder+1,0,prhs->_yOrder+1) += 
                *prhs->_coeffs;
            _coeffs = newCoeffs;
            _xOrder = newXOrder;
            _yOrder = newYOrder;
        }
    }

void lsst::meas::algorithms::shapelet::Polynomial2D::setFunction ( int  xOrder, int  yOrder, const DVector &  fVect  )

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 63 of file Function2D.cc.

    {
        if(_xOrder != xo || _yOrder != yo) {
            _xOrder = xo; _yOrder = yo;
            _coeffs.reset(new DMatrix(xo+1,yo+1));
            _coeffs->setZero();
        }
        int k=0;

        int maxOrder = std::max(xo,yo);
        for(int m=0;m<=maxOrder;++m) {
            int i0 = std::min(xo,m);
            int len = std::min(yo,i0)+1;
#ifdef USE_TMV
            DVectorView coeffDiag = _coeffs->subVector(i0,m-i0,-1,1,len);
            tmv::ConstVectorView<double> subf = fVect.subVector(k,k+len);
            coeffDiag = subf;
#else
            for(int i=0;i<len;++i)
                (*_coeffs)(i0-i,m-i0+i) = fVect(k+i);
#endif
            k += len;
        }

        Assert(k==(int)fVect.size());
    }

void lsst::meas::algorithms::shapelet::Polynomial2D::write ( std::ostream &  fout ) const

virtual

Implements lsst::meas::algorithms::shapelet::Function2D.

Definition at line 122 of file Function2D.cc.

    {
        int oldPrec = fout.precision(6);
        std::ios_base::fmtflags oldf = 
            fout.setf(std::ios_base::scientific,std::ios_base::floatfield);
        int maxOrder = std::max(_xOrder,_yOrder);
        if (maxOrder == 0) {
            fout << "C " << (*_coeffs)(0,0) << std::endl;
        } else {
            fout << "P " << _xOrder << ' ' << _yOrder << ' ' << _scale << ' ';
            for(int m=0;m<=maxOrder;++m) {
                int i0 = std::min(_xOrder,m);
                int len = std::min(_yOrder,i0)+1;
#ifdef USE_TMV
                DVectorView coeffDiag = _coeffs->subVector(i0,m-i0,-1,1,len);
                for(int i=0;i<len;++i) fout << coeffDiag(i) << ' ';
#else
                for(int i=0;i<len;++i) fout << (*_coeffs)(i0-i,m-i0+i);
#endif
            }
        }
        fout << std::endl;
        if (!fout) throw std::runtime_error("writing (polynomial) function");
        fout.flags(oldf);
        fout.precision(oldPrec);
    }

Member Data Documentation

double lsst::meas::algorithms::shapelet::Polynomial2D::_scale

private

Definition at line 277 of file Function2D.h.

---

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

• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/include/lsst/meas/algorithms/shapelet/Function2D.h
• /home/lsstsw/stack/Linux64/meas_algorithms/11.0-2-gb8b8ce7/src/shapelet/Function2D.cc