bspline.h

Go to the documentation of this file.

//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //
//                                                                                   //
//                       / /   / /    __    \ \  / /                                 //
//                      / /__ / /   / _ \    \ \/ /                                  //
//                     /  ___  /   | |/_/    / /\ \                                  //
//                    / /   / /    \_\      / /  \ \                                 //
//                                                                                   //
//                                                                                   //
//  Copyright (c) 2016, Jakub Benda, Charles University in Prague                    //
//                                                                                   //
// MIT License:                                                                      //
//                                                                                   //
//  Permission is hereby granted, free of charge, to any person obtaining a          //
// copy of this software and associated documentation files (the "Software"),        //
// to deal in the Software without restriction, including without limitation         //
// the rights to use, copy, modify, merge, publish, distribute, sublicense,          //
// and/or sell copies of the Software, and to permit persons to whom the             //
// Software is furnished to do so, subject to the following conditions:              //
//                                                                                   //
//  The above copyright notice and this permission notice shall be included          //
// in all copies or substantial portions of the Software.                            //
//                                                                                   //
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS          //
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,       //
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE       //
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, //
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF         //
// OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  //
//                                                                                   //
//  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *  //

#ifndef HEX_ECS_BSPLINE
#define HEX_ECS_BSPLINE

// --------------------------------------------------------------------------------- //

#include "hex-arrays.h"
#include "hex-misc.h"

// --------------------------------------------------------------------------------- //

class Bspline
{
    public:
    
        Bspline
        (
            int order,
            Real th,
            rArrayView cknots1,
            rArrayView rknots,
            rArrayView cknots2
        );
        
        Complex bspline (int i, int iknot, int k, Complex r) const;
        
        Complex dspline (int i, int iknot, int k, Complex r) const;
        
        void B (int i, int iknot, int n, const Complex* x, Complex* y) const;
        
        void dB (int i, int iknot, int n, const Complex* x, Complex* y) const;
        
        Complex rotate (Real r) const
        {
            // leading complex part
            if (r < R1_)
                return R1_ + (r - R1_) * rotation_;
            
            // trailing complex part
            if (r > R2_)
                return R2_ + (r - R2_) * rotation_;
            
            // real part
            return r;
        };
        
        Real unrotate (Complex z) const
        {
            // leading complex part
            if (z.imag() < 0)
                return R1_ + (z.real() - R1_) / rotation_.real();
            
            // trailing complex part
            if (z.imag() > 0)
                return R2_ + (z.real() - R2_) / rotation_.real();
            
            // real part
            return z.real();
        };
        
        Complex clamp (Complex z, Real a, Real b) const;
        
        cArray zip (const cArrayView coeff, const rArrayView grid) const;
        
        cArray zip (const cArrayView coeff, const rArrayView xgrid, const rArrayView ygrid) const;
        
        static cArray zip
        (
            Bspline const & bx,
            Bspline const & by,
            const cArrayView coeff,
            const rArrayView xgrid,
            const rArrayView ygrid,
            Complex (Bspline::* evalXBSpline) (int,int,int,Complex) const = &Bspline::bspline,
            Complex (Bspline::* evalYBSpline) (int,int,int,Complex) const = &Bspline::bspline
        );
        
        int knot (Complex x) const;
        
        Complex eval (const cArrayView coeff, Real x) const;
        
        Complex eval (const cArrayView coeff, Real x, Real y) const;
        
        // getters
        
        cArrayView t () const { return t_; }
        
        Complex const & t (int i) const { return t_[i]; }
        
        int Nspline () const { return Nspline_; }
        
        int Nknot () const { return Nknot_; }
        
        int Nreknot () const { return Nreknot_; }
        
        int order () const { return order_; }
        
        int iR1 () const { return cknots1_.empty() ? 0 : cknots1_.size() - 1; }
        
        int iR2 () const { return cknots2_.empty() ? t_.size() - 1 : t_.size() - cknots2_.size(); }
        
        Real R1 () const { return R1_; }
        
        Real R2 () const { return R2_; }
        
        Real Rmin () const { return Rmin_; }
        
        Real Rmax () const { return Rmax_; };
        
        Real ECStheta () const { return theta_; }
        
        rArray const & rknots () const { return rknots_; }
        
        rArray const & cknots1 () const { return cknots1_; }
        rArray const & cknots2 () const { return cknots2_; }
        
        std::size_t hash () const;
        
    private:
    
        rArray rknots_;
        
        rArray cknots1_, cknots2_;
        
        cArray t_;
        
        Real theta_;
        
        Complex rotation_;
        
        Real R1_;
        
        Real R2_;
        
        Real Rmin_;
        
        Real Rmax_;
        
        int Nknot_;
        
        int Nreknot_;
        
        int Nspline_;
        
        int Nintval_;
        
        int order_;
        
        mutable rArrays work_;
        
        static const std::size_t work_size_;
};

// --------------------------------------------------------------------------------- //

#endif // HEX_ECS_BSPLINE