BSplineBase.h

Go to the documentation of this file.

/************************************************************************
 * Copyright 2022 University Corporation for Atmospheric Research.
 * All rights reserved.
 *
 * Use of this code is subject to the standard BSD license:
 *
 *  http://www.opensource.org/licenses/bsd-license.html
 *
 * See the COPYRIGHT file in the source distribution for the license text,
 * or see this web page:
 *
 *  http://www.eol.ucar.edu/homes/granger/bspline/doc/
 *
 *************************************************************************/
#ifndef BSPLINEBASE_H_
#define BSPLINEBASE_H_
 
#include <memory>
 
template <class T> class BSpline;
 
/*
 * Opaque member structure to hide the matrix implementation.
 */
template <class T> struct BSplineBaseP;
 
template <class T> class BSplineBase
{
public:
    // Datum type
    typedef T datum_type;
 
    static const char* Version();
 
    static bool Debug(int on = -1);
 
    enum BoundaryConditionTypes
    {
        BC_ZERO_ENDPOINTS = 0,
        BC_ZERO_FIRST = 1,
        BC_ZERO_SECOND = 2
    };
 
public:
    BSplineBase(const T* x, int nx, double wl, int bc_type = BC_ZERO_SECOND,
                int num_nodes = 0);
 
    BSplineBase(const BSplineBase& bb);
 
    BSplineBase& operator=(const BSplineBase& right);
 
    // Declare the destructor so it is not implicitly instantiated.  It can
    // only be instantiated with the full implementation in BSplineBase.cpp.
    ~BSplineBase();
 
    bool setDomain(const T* x, int nx, double wl, int bc_type = BC_ZERO_SECOND,
                   int num_nodes = 0);
 
    BSpline<T>* apply(const T* y);
 
    const T* nodes(int* nnodes);
 
    int
    nNodes()
    {
        return M + 1;
    }
 
    int
    nX()
    {
        return NX;
    }
 
    T
    Xmin()
    {
        return xmin;
    }
 
    T
    Xmax()
    {
        return xmin + (M * DX);
    }
 
    double Alpha(double wavelength);
 
    double
    Alpha()
    {
        return alpha;
    }
 
    bool
    ok()
    {
        return OK;
    }
 
protected:
    typedef BSplineBaseP<T> Base;
 
    // Provided
    double waveLength; // Cutoff wavelength (l sub c)
    int NX;
    int K;  // Degree of derivative constraint (currently fixed at 2)
    int BC; // Boundary conditions type (0,1,2)
 
    // Derived
    T xmax;
    T xmin;
    int M;     // Number of intervals (M+1 nodes)
    double DX; // Interval length in same units as X
    double alpha;
    bool OK;
    // Hide more complicated state members from the public interface.
    std::unique_ptr<Base> base;
 
    bool Setup(int num_nodes = 0);
    void calculateQ();
    double qDelta(int m1, int m2);
    double Beta(int m);
    void addP();
    bool factor();
    double Basis(int m, T x);
    double DBasis(int m, T x);
 
    static const double BoundaryConditions[3][4];
    static const double PI;
 
    double Ratiod(int&, double&, double&);
};
 
#endif /*BSPLINEBASE_H_*/