B d @shdZddlZddlmZmZddlmZmZddl m Z ddl m Z ddl mZmZmZd d d d d dddddddg ZGdddeZGdddeZGdddeZGdddeZGdd d eZGdd d eZGdd d eZGdddeZGdddeZGd ddeZGd!d d eZGd"ddeZGd#d$d$eZGd%ddeZGd&d d eZ dS)'zN This module contains models representing polynomials and polynomial series. N)indentcheck_broadcast) FittableModelModel)Shift) Parameter)poly_map_domaincomb_validate_domain_window Chebyshev1D Chebyshev2D Hermite1D Hermite2D InverseSIP Legendre1D Legendre2D Polynomial1D Polynomial2DSIPOrthoPolynomialBasePolynomialModelc@s(eZdZdZdZdZdZeddZdS)PolynomialBasez Base class for all polynomial-like models with an arbitrary number of parameters in the form of coefficients. In this case Parameter instances are returned through the class's ``__getattr__`` rather than through class descriptors. TFcCs|jS)aCoefficient names generated based on the model's polynomial degree and number of dimensions. Subclasses should implement this to return parameter names in the desired format. On most `Model` classes this is a class attribute, but for polynomial models it is an instance attribute since each polynomial model instance can have different parameters depending on the degree of the polynomial and the number of dimensions, for example. ) _param_names)selfrrh/work/yifan.wang/ringdown/master-ringdown-env/lib/python3.7/site-packages/astropy/modeling/polynomial.py param_names(szPolynomialBase.param_namesN) __name__ __module__ __qualname____doc__rZlinearZ col_fit_derivpropertyrrrrrrs rcsFeZdZdZd fdd ZeddZddZd d Zd d Z Z S)rz Base class for polynomial models. Its main purpose is to determine how many coefficients are needed based on the polynomial order and dimension and to provide their default values, names and ordering. Nc  s||_||j|_||j|_|rB|dkr2d}d||f}nd}x&|jD]}t|t|d|j |<qNWt j f||||d|dS)Nr)rr)default)n_modelsmodel_set_axisnamemeta) _degree get_num_coeffn_inputs_order_generate_coeff_namesrrnpzeros _parameters_super__init__) rdegreer$r%r&r'paramsminshape param_name) __class__rrr1Bs zPolynomialModel.__init__cCs|jS)zDegree of polynomial.)r()rrrrr2UszPolynomialModel.degreecCsB|jdkrtd|dkr(t|j|}nd}|j||d}|S)zH Return the number of coefficients in one parameter set rz-Degree of polynomial must be positive or nullr)r2 ValueErrorr )rndimnmixednumcrrrr)[s zPolynomialModel.get_num_coeffcCs\g}|jd}x>t|D]2}x,t|D] }|||jkr&|||fq&WqW|dddS)Nr)r2rangeappend)rclencoeffijrrr_invlexks zPolynomialModel._invlexcCsg}|dkr2xt|jD]}|d|qWnx,t|jdD]}|d|ddqBWx.td|jdD]}|ddd|qrWxRtd|jD]B}x_r)r<r+r=r2tuple)rr8namesnr@rArrrr,tsz%PolynomialModel._generate_coeff_names)NNNN) rrr r!r1r"r2r)rBr, __classcell__rr)r6rr9s  csneZdZdZdfdd ZeddZejddZedd Zejd d Zd d Z d dZ ddZ Z S)_PolyDomainWindow1DzF This class sets ``domain`` and ``window`` of 1D polynomials. Nc  s.tj|||f||d||||dS)N)r&r')r0r1_set_default_domain_window) rr2domainwindowr$r%r&r'r3)r6rrr1sz_PolyDomainWindow1D.__init__cCs|jS)N)_window)rrrrrKsz_PolyDomainWindow1D.windowcCst||_dS)N)r rL)rvalrrrrKscCs|jS)N)_domain)rrrrrJsz_PolyDomainWindow1D.domaincCst||_dS)N)r rN)rrMrrrrJscCs(ddd|_t|pd|_t||_dS)z^ This method sets the ``domain`` and ``window`` attributes on 1D subclasses. N)r;r)rJrK)_default_domain_windowr rLrN)rrJrKrrrrIs z._PolyDomainWindow1D._set_default_domain_windowcCs |j|jg|j|jd|jdS)N)rJrK)kwargsdefaults) _format_reprr2rJrKrO)rrrr__repr__s  z_PolyDomainWindow1D.__repr__cCs&|d|jfd|jfd|jfg|jS)NDegreeDomainZWindow) _format_strr2rJrKrO)rrrr__str__s  z_PolyDomainWindow1D.__str__)NNNNNN) rrr r!r1r"rKsetterrJrIrSrWrGrr)r6rrHs   rHcseZdZdZdZdZd)fdd ZeddZej d dZed d Z e j d d Z ed dZ e j ddZ eddZ e j ddZ ddZ ddZddZddZddZddZdd Zd!d"Zd#d$Zd%d&Zfd'd(ZZS)*raM This is a base class for the 2D Chebyshev and Legendre models. The polynomials implemented here require a maximum degree in x and y. For explanation of ``x_domain``, ``y_domain``, ```x_window`` and ```y_window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- x_degree : int degree in x y_degree : int degree in y x_domain : tuple or None, optional domain of the x independent variable x_window : tuple or None, optional range of the x independent variable y_domain : tuple or None, optional domain of the y independent variable y_window : tuple or None, optional range of the y independent variable **params : dict {keyword: value} pairs, representing {parameter_name: value} rNc  s||_||_||_ddddd|_t|p4|jd|_t|pH|jd|_t||_t||_ | |_ |r|dkr|d}d||f} nd} x&|j D]} t | t | d|j| <qWtjf||| | d | dS) N)r;r)x_windowy_windowx_domainy_domainrZr[r)rr)r#)r$r%r&r')x_degreey_degreer)r+rOr _x_window _y_window _x_domain _y_domainr,rrr-r.r/r0r1)rr^r_r\rZr]r[r$r%r&r'r3r4r5)r6rrr1s,      zOrthoPolynomialBase.__init__cCs|jS)N)rb)rrrrr\szOrthoPolynomialBase.x_domaincCst||_dS)N)r rb)rrMrrrr\scCs|jS)N)rc)rrrrr]szOrthoPolynomialBase.y_domaincCst||_dS)N)r rc)rrMrrrr]scCs|jS)N)r`)rrrrrZ szOrthoPolynomialBase.x_windowcCst||_dS)N)r r`)rrMrrrrZscCs|jS)N)ra)rrrrr[szOrthoPolynomialBase.y_windowcCst||_dS)N)r ra)rrMrrrr[scCs,|j|j|jg|j|j|j|jd|jdS)N)r\r]rZr[)rPrQ)rRr^r_r\r]rZr[rO)rrrrrSs zOrthoPolynomialBase.__repr__c Cs>|d|jfd|jfd|jfd|jfd|jfd|jfg|jS)NZX_DegreeZY_DegreeX_DomainY_DomainX_WindowY_Window)rVr^r_r\r]rZr[rO)rrrrrW#s zOrthoPolynomialBase.__str__cCs|jd|jdS)z Determine how many coefficients are needed Returns ------- numc : int number of coefficients r)r^r_)rrrrr)-s z!OrthoPolynomialBase.get_num_coeffcCsbg}t|jd}t|jd}x(|D] }x|D]}|||fq4Wq*Wt|dddS)Nrr;)r-aranger^r_r=array)rr>xvaryvarrAr@rrrrB9s  zOrthoPolynomialBase._invlexc Cs~g}t|jd}t|jd}xD|D]<}x6|D].}d|d|}||j|}||q4Wq*Wt|dddS)Nrr>rCr;)r-rhr^r_rindexr=ri) rcoeffs invlex_coeffsrjrkrAr@r&coeffrrr invlex_coeffDs  z OrthoPolynomialBase.invlex_coeffcCs|}|dddf|jd|dddf<|jd}|jd}t||d||f}xrC)r<r_r^r=rD)rrErAr@rrrr,ys z)OrthoPolynomialBase._generate_coeff_namescCs tddS)zk Computation and store the individual functions. To be implemented by subclasses" z Subclasses should implement thisN)NotImplementedError)rrrrrrr~szOrthoPolynomialBase._fcachecGsL|jdk rt||j|j}|jdk r4t||j|j}||}||||S)N)r\r rZr]r[rpr)rrrrminvcoeffrrrevaluates    zOrthoPolynomialBase.evaluatec s>tj||f|\}}|\}}|j|jkr2td||f|fS)Nz,Expected input arrays to have the same shape)r0prepare_inputsshaper7)rrrrPinputs format_info)r6rrrs  z"OrthoPolynomialBase.prepare_inputs)NNNNNNNN)rrr r!r* n_outputsr1r"r\rXr]rZr[rSrWr)rBrprxrr,r~rrrGrr)r6rrs2          csVeZdZdZdZdZdZdfdd ZddZfd d Z d d Z e d dZ Z S)r ac Univariate Chebyshev series. It is defined as: .. math:: P(x) = \sum_{i=0}^{i=n}C_{i} * T_{i}(x) where ``T_i(x)`` is the corresponding Chebyshev polynomial of the 1st kind. For explanation of ```domain``, and ``window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- degree : int degree of the series domain : tuple or None, optional window : tuple or None, optional If None, it is set to (-1, 1) Fitters will remap the domain to this window. **params : dict keyword : value pairs, representing parameter_name: value Notes ----- This model does not support the use of units/quantities, because each term in the sum of Chebyshev polynomials is a polynomial in x - since the coefficients within each Chebyshev polynomial are fixed, we can't use quantities for x since the units would not be compatible. For example, the third Chebyshev polynomial (T2) is 2x^2-1, but if x was specified with units, 2x^2 and -1 would have incompatible units. rTNc s&tj|f||||||d|dS)N)rJrKr$r%r&r')r0r1) rr2rJrKr$r%r&r'r3)r6rrr1szChebyshev1D.__init__cGstj|tddd}tj|jdf|j|jd}d|d<|jdkrd|}||d<x8td|jdD]$}||d|||d||<qdWt|d|j S)a1 Computes the Vandermonde matrix. Parameters ---------- x : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix Fr)dtypecopyndmin)rrrY) r-rifloatemptyr2rrr<rollaxisr8)rrr3vx2r@rrr fit_derivs $zChebyshev1D.fit_derivc s&tj|f|\}}|d}|f|fS)Nr)r0r)rrrPrr)r6rrrszChebyshev1D.prepare_inputscGs&|jdk rt||j|j}|||S)N)rJr rKclenshaw)rrrmrrrrs zChebyshev1D.evaluatecCst|dkr|d}d}npt|dkr8|d}|d}nRd|}|d}|d}x8tdt|dD]"}|}|| |}|||}qdW|||S)z4Evaluates the polynomial using Clenshaw's algorithm.rrrYrrr;rq)rtr<)rrmc0c1rr@tmprrrrs   zChebyshev1D.clenshaw)NNNNNN)rrr r!r*r _separabler1rrr staticmethodrrGrr)r6rr s# csVeZdZdZdZdZdZdfdd ZddZfd d Z d d Z e d dZ Z S)ra\ Univariate Hermite series. It is defined as: .. math:: P(x) = \sum_{i=0}^{i=n}C_{i} * H_{i}(x) where ``H_i(x)`` is the corresponding Hermite polynomial ("Physicist's kind"). For explanation of ``domain``, and ``window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- degree : int degree of the series domain : tuple or None, optional window : tuple or None, optional If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword : value pairs, representing parameter_name: value Notes ----- This model does not support the use of units/quantities, because each term in the sum of Hermite polynomials is a polynomial in x - since the coefficients within each Hermite polynomial are fixed, we can't use quantities for x since the units would not be compatible. For example, the third Hermite polynomial (H2) is 4x^2-2, but if x was specified with units, 4x^2 and -2 would have incompatible units. rTNc  s&tj|||f||||d|dS)N)r$r%r&r')r0r1) rr2rJrKr$r%r&r'r3)r6rrr10s zHermite1D.__init__cGstj|tddd}tj|jdf|j|jd}d|d<|jdkrd|}d||d<xDtd|jdD]0}|||dd|d||d||<qhWt|d|j S)a1 Computes the Vandermonde matrix. Parameters ---------- x : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix Fr)rrr)rrrY) r-rirrr2rrr<rr8)rrr3rrr@rrrr6s  0zHermite1D.fit_derivc s&tj|f|\}}|d}|f|fS)Nr)r0r)rrrPrr)r6rrrQszHermite1D.prepare_inputscGs&|jdk rt||j|j}|||S)N)rJr rKr)rrrmrrrrXs zHermite1D.evaluatecCs|d}t|dkr"|d}d}nt|dkr@|d}|d}nft|}|d}|d}xLtdt|dD]6}|}|d}|| |d|d}|||}qlW|||S)NrYrrrrr;rq)rtr<)rrmrrrndr@temprrrr]s    zHermite1D.clenshaw)NNNNNN)rrr r!r*rrr1rrrrrrGrr)r6rrs# cs>eZdZdZdZd fdd ZddZdd Zd d ZZ S) ra Bivariate Hermite series. It is defined as .. math:: P_{nm}(x,y) = \sum_{n,m=0}^{n=d,m=d}C_{nm} H_n(x) H_m(y) where ``H_n(x)`` and ``H_m(y)`` are Hermite polynomials. For explanation of ``x_domain``, ``y_domain``, ``x_window`` and ``y_window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- x_degree : int degree in x y_degree : int degree in y x_domain : tuple or None, optional domain of the x independent variable y_domain : tuple or None, optional domain of the y independent variable x_window : tuple or None, optional range of the x independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window y_window : tuple or None, optional range of the y independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword: value pairs, representing parameter_name: value Notes ----- This model does not support the use of units/quantities, because each term in the sum of Hermite polynomials is a polynomial in x and/or y - since the coefficients within each Hermite polynomial are fixed, we can't use quantities for x and/or y since the units would not be compatible. For example, the third Hermite polynomial (H2) is 4x^2-2, but if x was specified with units, 4x^2 and -2 would have incompatible units. FNc s,tj||f||||||| | d| dS)N)r\r]rZr[r$r%r&r')r0r1) rr^r_r\rZr]r[r$r%r&r'r3)r6rrr1s zHermite2D.__init__cCs|jd}|jd}i}t|j|d<d||d<t|j||<d|||d<xBtd|D]4}d|||dd|d||d||<qhWxJt|d||D]4}d|||dd|d||d||<qW|S)zv Calculate the individual Hermite functions once and store them in a dictionary to be reused. rrrY)r^r_r-onesrrr<)rrrrrrrFrrrr~s  44zHermite2D._fcachec Gs|j|jkrtd|}|}|||jdj}|||jdj}g}xDt|jdD]2}x,t|jdD]}|||||qtWq`Wt |} | jS)a Derivatives with respect to the coefficients. This is an array with Hermite polynomials: .. math:: H_{x_0}H_{y_0}, H_{x_1}H_{y_0}...H_{x_n}H_{y_0}...H_{x_n}H_{y_m} Parameters ---------- x : ndarray input y : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix z x and y must have the same shaper) rr7flatten _hermderiv1dr^Tr_r<r=r-ri) rrrr3x_derivy_derivijr@rArrrrrs  zHermite2D.fit_derivcCstj|tddd}tj|dt|f|jd}|dd|d<|dkrd|}||d<xBtd|dD]0}|||dd|d||d||<qfWt|d|jS)z1 Derivative of 1D Hermite series Fr)rrr)rrrY) r-rirrrtrr<rr8)rrdegdrr@rrrrs0zHermite2D._hermderiv1d)NNNNNNNN) rrr r!rr1r~rrrGrr)r6rrrs,)csVeZdZdZdZdZdZdfdd ZfddZd d Z d d Z e d dZ Z S)raT Univariate Legendre series. It is defined as: .. math:: P(x) = \sum_{i=0}^{i=n}C_{i} * L_{i}(x) where ``L_i(x)`` is the corresponding Legendre polynomial. For explanation of ``domain``, and ``window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- degree : int degree of the series domain : tuple or None, optional window : tuple or None, optional If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword: value pairs, representing parameter_name: value Notes ----- This model does not support the use of units/quantities, because each term in the sum of Legendre polynomials is a polynomial in x - since the coefficients within each Legendre polynomial are fixed, we can't use quantities for x since the units would not be compatible. For example, the third Legendre polynomial (P2) is 1.5x^2-0.5, but if x was specified with units, 1.5x^2 and -0.5 would have incompatible units. rTNc  s&tj|||f||||d|dS)N)r$r%r&r')r0r1) rr2rJrKr$r%r&r'r3)r6rrr1 s zLegendre1D.__init__c s&tj|f|\}}|d}|f|fS)Nr)r0r)rrrPrr)r6rrr&szLegendre1D.prepare_inputscGs&|jdk rt||j|j}|||S)N)rJr rKr)rrrmrrrr-s zLegendre1D.evaluatecGstj|tddd}tj|jdf|j|jd}d|d<|jdkr||d<xPtd|jdD]<}||d|d|d||d|d|||<q\Wt|d|j S)a1 Computes the Vandermonde matrix. Parameters ---------- x : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix Fr)rrr)rrrY) r-rirrr2rrr<rr8)rrr3rr@rrrr2s <zLegendre1D.fit_derivcCst|dkr|d}d}nt|dkr8|d}|d}nvt|}|d}|d}x\tdt|dD]F}|}|d}|| ||d|}|||d|d|}qdW|||S)NrrrYrrr;rq)rtr<)rrmrrrr@rrrrrLs    zLegendre1D.clenshaw)NNNNNN)rrr r!r*rrr1rrrrrrGrr)r6rrs$ csjeZdZdZdZdZdZdfdd ZfddZd d Z d d Z e d dZ e ddZddZZS)ra` 1D Polynomial model. It is defined as: .. math:: P = \sum_{i=0}^{i=n}C_{i} * x^{i} For explanation of ``domain``, and ``window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- degree : int degree of the series domain : tuple or None, optional If None, it is set to (-1, 1) window : tuple or None, optional If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword: value pairs, representing parameter_name: value rTNc  sZtj|||f||||d|ddd|_t|p<|jd|_t|pP|jd|_dS)N)r$r%r&r')r;r)rJrKrJrK)r0r1rOr rN) rr2rJrKr$r%r&r'r3)r6rrr1s  zPolynomial1D.__init__c s&tj|f|\}}|d}|f|fS)Nr)r0r)rrrPrr)r6rrrszPolynomial1D.prepare_inputscGs&|jdk rt||j|j}|||S)N)rJr rKhorner)rrrmrrrrs zPolynomial1D.evaluatecGsttj|jdf|jtd}d|d<|jdkrd||d<x,td|jdD]}||d|||<qHWt|d|jS)a1 Computes the Vandermonde matrix. Parameters ---------- x : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix r)rrrY)r-rr2rrr<rr8)rrr3rr@rrrrs zPolynomial1D.fit_derivcCs^t|dkr$|dtj|dd}n6|d}x,tdt|dD]}|| ||}q@W|S)Nrr;F)subokrY)rtr-Z ones_liker<)rrmrr@rrrrs  zPolynomial1D.hornercCs8|jdks|jjdkrdS|jd|jj|jjiSdS)Nr)r2runitrr)rrrr input_unitsszPolynomial1D.input_unitscCsVi}xLt|jdD]:}t|d|}||jd||jd|||j<qW|S)Nrr>r)r<r2routputsrr&)r inputs_unit outputs_unitmappingr@parrrr_parameter_units_for_data_unitss *z,Polynomial1D._parameter_units_for_data_units)NNNNNN)rrr r!r*rrr1rrrrrr"rrrGrr)r6rr`s  cseZdZdZdZdZdZd&fdd Zfdd Zd d Z d d Z ddZ ddZ ddZ ddZeddZddZeddZejddZeddZejddZed d!Zejd"d!Zed#d$Zejd%d$ZZS)'ra 2D Polynomial model. Represents a general polynomial of degree n: .. math:: P(x,y) = c_{00} + c_{10}x + ...+ c_{n0}x^n + c_{01}y + ...+ c_{0n}y^n + c_{11}xy + c_{12}xy^2 + ... + c_{1(n-1)}xy^{n-1}+ ... + c_{(n-1)1}x^{n-1}y For explanation of ``x_domain``, ``y_domain``, ``x_window`` and ``y_window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- degree : int Polynomial degree: largest sum of exponents (:math:`i + j`) of variables in each monomial term of the form :math:`x^i y^j`. The number of terms in a 2D polynomial of degree ``n`` is given by binomial coefficient :math:`C(n + 2, 2) = (n + 2)! / (2!\,n!) = (n + 1)(n + 2) / 2`. x_domain : tuple or None, optional domain of the x independent variable If None, it is set to (-1, 1) y_domain : tuple or None, optional domain of the y independent variable If None, it is set to (-1, 1) x_window : tuple or None, optional range of the x independent variable If None, it is set to (-1, 1) Fitters will remap the x_domain to x_window y_window : tuple or None, optional range of the y independent variable If None, it is set to (-1, 1) Fitters will remap the y_domain to y_window **params : dict keyword: value pairs, representing parameter_name: value rYrFNc  stj|f|||| d| ddddd|_t|p<|jd|_t|pP|jd|_t|pd|jd|_t|px|jd|_dS)N)r$r%r&r')r;r)r\r]rZr[r\r]rZr[)r0r1rOr rbrcr`ra) rr2r\r]rZr[r$r%r&r'r3)r6rrr1s zPolynomial2D.__init__c s*tj||f|\}}|\}}||f|fS)N)r0r)rrrrPrr)r6rrr szPolynomial2D.prepare_inputscGs|jdk rt||j|j}|jdk r4t||j|j}||}||||}|jdkrtt |d|j }|rt |}||dd<|}|S)Nr) r\r rZr]r[rpmultivariate_hornerr2rr-rr)rrrrmrrZ output_shapeZ new_resultrrrrs      zPolynomial2D.evaluatecCs(|j|jg|j|j|j|jd|jdS)N)r\r]rZr[)rPrQ)rRr2r\r]rZr[rO)rrrrrS&s  zPolynomial2D.__repr__cCs6|d|jfd|jfd|jfd|jfd|jfg|jS)NrTrdrerfrg)rVr2r\r]rZr[rO)rrrrrW.s   zPolynomial2D.__str__c Gs|jdkr|}|jdkr$|}|j|jkr8td|dddft|jd}|dddftd|jd}g}xNtd|jD]>}x8td|jD](}|||jkr|||||qWqWt |j }| rt |||g} nt ||g} | S)aW Computes the Vandermonde matrix. Parameters ---------- x : ndarray input y : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix rYz$Expected x and y to be of equal sizeNr) r8rsizer7r-rhr2r<r=riranyZhstack) rrrr3ZdesignxZdesignyZ designmixedr@rArrrrr6s$    " zPolynomial2D.fit_derivcCstg}t|jd}xR|D]J}xD|D]<}|||jkr"d|d|}||j|}||q"WqW|dddS)Nrr>rCr;)r<r2rrlr=)rrmrnr?r@rAr&rorrrrp_s  zPolynomial2D.invlex_coeffc Cs|}|d}|d}|d}tj|dd}x`tt|D]P} || dfdkrt||||}tj|ddd}n |||}|| d}qrCr)r<r2rrrr&)rrrrr@rArrrrrs @z,Polynomial2D._parameter_units_for_data_unitscCs|jS)N)rb)rrrrr\szPolynomial2D.x_domaincCst||_dS)N)r rb)rrMrrrr\scCs|jS)N)rc)rrrrr]szPolynomial2D.y_domaincCst||_dS)N)r rc)rrMrrrr]scCs|jS)N)r`)rrrrrZszPolynomial2D.x_windowcCst||_dS)N)r r`)rrMrrrrZscCs|jS)N)ra)rrrrr[szPolynomial2D.y_windowcCst||_dS)N)r ra)rrMrrrr[s)NNNNNNNN)rrr r!r*rrr1rrrSrWrrprr"rrr\rXr]rZr[rGrr)r6rrs0% )      cs>eZdZdZdZd fdd ZddZdd Zd d ZZ S) r a Bivariate Chebyshev series.. It is defined as .. math:: P_{nm}(x,y) = \sum_{n,m=0}^{n=d,m=d}C_{nm} T_n(x ) T_m(y) where ``T_n(x)`` and ``T_m(y)`` are Chebyshev polynomials of the first kind. For explanation of ``x_domain``, ``y_domain``, ``x_window`` and ``y_window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- x_degree : int degree in x y_degree : int degree in y x_domain : tuple or None, optional domain of the x independent variable y_domain : tuple or None, optional domain of the y independent variable x_window : tuple or None, optional range of the x independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window y_window : tuple or None, optional range of the y independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword: value pairs, representing parameter_name: value Notes ----- This model does not support the use of units/quantities, because each term in the sum of Chebyshev polynomials is a polynomial in x and/or y - since the coefficients within each Chebyshev polynomial are fixed, we can't use quantities for x and/or y since the units would not be compatible. For example, the third Chebyshev polynomial (T2) is 2x^2-1, but if x was specified with units, 2x^2 and -1 would have incompatible units. FNc s,tj||f||||||| | d| dS)N)r\r]rZr[r$r%r&r')r0r1) rr^r_r\rZr]r[r$r%r&r'r3)r6rrr1s zChebyshev2D.__init__cCs|jd}|jd}i}t|j|d<||d<t|j||<|||d<x6td|D](}d|||d||d||<q`Wx>t|d||D](}d|||d||d||<qW|S)zx Calculate the individual Chebyshev functions once and store them in a dictionary to be reused. rrrY)r^r_r-rrrr<)rrrrrrrFrrrr~s   ((zChebyshev2D._fcachec Gs|j|jkrtd|}|}|||jdj}|||jdj}g}xDt|jdD]2}x,t|jdD]}|||||qtWq`Wt |} | jS)a Derivatives with respect to the coefficients. This is an array with Chebyshev polynomials: .. math:: T_{x_0}T_{y_0}, T_{x_1}T_{y_0}...T_{x_n}T_{y_0}...T_{x_n}T_{y_m} Parameters ---------- x : ndarray input y : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix z x and y must have the same shaper) rr7r _chebderiv1dr^rr_r<r=r-ri) rrrr3rrrr@rArrrrrs  zChebyshev2D.fit_derivcCstj|tddd}tj|dt|f|jd}|dd|d<|dkrd|}||d<x6td|dD]$}||d|||d||<qfWt|d|jS)z3 Derivative of 1D Chebyshev series Fr)rrr)rrrY) r-rirrrtrr<rr8)rrrrrr@rrrr+s$zChebyshev2D._chebderiv1d)NNNNNNNN) rrr r!rr1r~rrrGrr)r6rr s-)cs>eZdZdZdZd fdd ZddZdd Zd d ZZ S) ra Bivariate Legendre series. Defined as: .. math:: P_{n_m}(x,y) = \sum_{n,m=0}^{n=d,m=d}C_{nm} L_n(x ) L_m(y) where ``L_n(x)`` and ``L_m(y)`` are Legendre polynomials. For explanation of ``x_domain``, ``y_domain``, ``x_window`` and ``y_window`` see :ref:`Notes regarding usage of domain and window `. Parameters ---------- x_degree : int degree in x y_degree : int degree in y x_domain : tuple or None, optional domain of the x independent variable y_domain : tuple or None, optional domain of the y independent variable x_window : tuple or None, optional range of the x independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window y_window : tuple or None, optional range of the y independent variable If None, it is set to (-1, 1) Fitters will remap the domain to this window **params : dict keyword: value pairs, representing parameter_name: value Notes ----- Model formula: .. math:: P(x) = \sum_{i=0}^{i=n}C_{i} * L_{i}(x) where ``L_{i}`` is the corresponding Legendre polynomial. This model does not support the use of units/quantities, because each term in the sum of Legendre polynomials is a polynomial in x - since the coefficients within each Legendre polynomial are fixed, we can't use quantities for x since the units would not be compatible. For example, the third Legendre polynomial (P2) is 1.5x^2-0.5, but if x was specified with units, 1.5x^2 and -0.5 would have incompatible units. FNc s,tj||f||||||| | d| dS)N)r\r]rZr[r$r%r&r')r0r1) rr^r_r\rZr]r[r$r%r&r'r3)r6rrr1qs zLegendre2D.__init__cCs|jd}|jd}i}t|j|d<||d<t|j||<|||d<xNtd|D]@}d|dd|||d|d||d|||<q`WxZtd|D]L}d|dd||||d|d|||d||||<qW|S)zw Calculate the individual Legendre functions once and store them in a dictionary to be reused. rrrY)r^r_r-rrrr<)rrrrrrrFrrrr~zs   ""*zLegendre2D._fcachec Gs|j|jkrtd|}|}|||jdj}|||jdj}g}xDt|jdD]2}x,t|jdD]}|||||qtWq`Wt |} | jS)a Derivatives with respect to the coefficients. This is an array with Legendre polynomials: Lx0Ly0 Lx1Ly0...LxnLy0...LxnLym Parameters ---------- x : ndarray input y : ndarray input *params throw-away parameter list returned by non-linear fitters Returns ------- result : ndarray The Vandermonde matrix z x and y must have the same shaper) rr7r_legendderiv1dr^rr_r<r=r-ri) rrrr3rrrr@rArrrrrs  zLegendre2D.fit_derivcCstj|tddd}tj|df|j|jd}|dd|d<|dkr||d<xNtd|dD]<}||d|d|d||d|d|||<q^Wt|d|jS)z$Derivative of 1D Legendre polynomialFr)rrr)rrrY) r-rirrrrr<rr8)rrrrr@rrrrs<zLegendre2D._legendderiv1d)NNNNNNNN) rrr r!rr1r~rrrGrr)r6rr;s3$csfeZdZdZdZdZdZdfdd Zdd Zd d Z d d Z ddZ ddZ ddZ ddZZS)_SIP1Dz This implements the Simple Imaging Polynomial Model (SIP) in 1D. It's unlikely it will be used in 1D so this class is private and SIP should be used instead. rYrFNc  s||_||_|||_|r8|dkr(d}d||f}nd}x&|jD]} t| t|d|j| <qDWtj f||||d|dS)Nr)rr)r#)r$r%r&r') order coeff_prefixr,rrr-r.r/r0r1) rrrr$r%r&r'r3r4r5)r6rrr1s   z_SIP1D.__init__cCs|j|j|jgdS)N)args)rRrr)rrrrrSsz_SIP1D.__repr__cCs|d|jfd|jfgS)NZOrderz Coeff. Prefix)rVrr)rrrrrWsz_SIP1D.__str__cGs||j|}||||S)N) _coeff_matrixr _eval_sip)rrrrmZmcoefrrrrsz_SIP1D.evaluatecCs>|jdks|jdkrtdt|j|}|j||d}|S)zD Return the number of coefficients in one param set rY z'Degree of polynomial must be 2< deg < 9)rr7r )rr8r9r:rrrr)s  z_SIP1D.get_num_coeffc Csg}x2td|jdD]}||d|ddqWx2td|jdD]}||ddd|qJWxVtd|jD]F}x@td|jD]0}|||jdkr||d|d|qWqzWt|S)NrYrrCr)r<rr=rD)rrrEr@rArrrr,s"z_SIP1D._generate_coeff_namescCst|jd|jdf}xDtd|jdD]0}|d|dd}||j|||df<q,WxDtd|jdD]0}|ddd|}||j||d|f<qrWxhtd|jD]X}xRtd|jD]B}|||jdkr|d|d|}||j||||f<qWqW|S)NrrYrCr)r-r.rr<rrl)rrrmmatr@attrrArrrrs z_SIP1D._coeff_matrixcCstj|tjd}tj|tjd}|jdkr8t|j}n t|j}xpt|jdD]^}xXt|jdD]F}d||kr|jdkrhnqh||||f||||}qhWqTW|S)N)rArr)r-ZasarrayZfloat64rr.rr<r)rrrZcoefrr@rArrrrs  "(z_SIP1D._eval_sip)NNNN)rrr r!r*rrr1rSrWrr)r,rrrGrr)r6rrs  rc sfeZdZdZdZdZdZiiddiiddddf fdd ZddZd d Z e d d Z d dZ Z S)ra Simple Imaging Polynomial (SIP) model. The SIP convention is used to represent distortions in FITS image headers. See [1]_ for a description of the SIP convention. Parameters ---------- crpix : list or (2,) ndarray CRPIX values a_order : int SIP polynomial order for first axis b_order : int SIP order for second axis a_coeff : dict SIP coefficients for first axis b_coeff : dict SIP coefficients for the second axis ap_order : int order for the inverse transformation (AP coefficients) bp_order : int order for the inverse transformation (BP coefficients) ap_coeff : dict coefficients for the inverse transform bp_coeff : dict coefficients for the inverse transform References ---------- .. [1] `David Shupe, et al, ADASS, ASP Conference Series, Vol. 347, 2005 `_ rYFNcs||_||_||_||_||_||_||_||_| |_t |d |_ t |d |_ t |fd| | d||_ t |fd| | d||_tj| | | | dd|_d|_dS) Nrrr)rr$r%B)r$r%r&r')ur)rr)Z_crpixZ_a_orderZ_b_orderZ_a_coeffZ_b_coeff _ap_order _bp_order _ap_coeff _bp_coeffrshift_ashift_brsip1d_asip1d_br0r1Z_inputsZ_outputs)rZcrpixZa_orderZb_orderZa_coeffZb_coeffap_orderbp_orderap_coeffbp_coeffr$r%r&r')r6rrr1Js&    z SIP.__init__cCs d|jj|j|j|j|jgS)Nz <{}({!r})>)formatr6rrrrr)rrrrrSas z SIP.__repr__cCsXd|jjg}x<|j|j|j|jgD]$}|tt|dd|dq&Wd |S)NzModel: )width ) r6rrrrrr=rrjoin)rpartsmodelrrrrWes z SIP.__str__cCs6|jdk r*|jdk r*t|j|j|j|jStddS)Nz+SIP inverse coefficients are not available.)rrrrrr)rrrrinversems  z SIP.inversecCsd|jj|f|jj}|jj|f|jj}|jj||f|jj}|jj||f|jj}||fS)N)rr param_setsrrr)rrrrrfgrrrrus z SIP.evaluate)rrr r!r*rrr1rSrWr"rrrGrr)r6rr$s csReZdZdZdZdZdZiiddddffdd ZddZd d Z d d Z Z S) rau Inverse Simple Imaging Polynomial Parameters ---------- ap_order : int order for the inverse transformation (AP coefficients) bp_order : int order for the inverse transformation (BP coefficients) ap_coeff : dict coefficients for the inverse transform bp_coeff : dict coefficients for the inverse transform rYFNc s||_||_||_||_|dd|ddtdd|D} tdd|D} tf||d| |_tf||d| |_ t j ||||ddS) NZAP_0_0rZBP_0_0css"|]\}}|dd|fVqdS)ZAP_r>N)replace).0rrrrr sz&InverseSIP.__init__..css"|]\}}|dd|fVqdS)ZBP_r>N)r)rrrrrrrs)r2r%)r$r%r&r') rrrr setdefaultdictitemsrsip1d_apsip1d_bpr0r1) rrrrrr$r%r&r'Zap_coeff_paramsZbp_coeff_params)r6rrr1s$     zInverseSIP.__init__cCsd|jjd|j|jgdS)N<(z)>)r6rrr)rrrrrSszInverseSIP.__repr__cCsPd|jjg}x4|j|jgD]$}|tt|dd|dqWd|S)NzModel: r)rrr)r6rrrr=rrr)rrrrrrrWs zInverseSIP.__str__cCs8|jj||f|jj}|jj||f|jj}||fS)N)rrrr)rrrx1y1rrrrszInverseSIP.evaluate) rrr r!r*rrr1rSrWrrGrr)r6rr}s)!r!numpyr-Z astropy.utilsrrcorerrZfunctional_modelsr parametersrutilsr r r __all__rrrHrr rrrrrr rrrrrrrrs<  !L4dkkkkldY