BSpline.h

Go to the documentation of this file.

/* -*- mode: c++; c-basic-offset: 4; -*- */
//
// BSpline.h: interface for the BSplineBase class.
//
/*
 * Copyright (c) 1998,1999
 * University Corporation for Atmospheric Research, UCAR
 *
 * Permission to use, copy, modify, distribute and sell this software and
 * its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and that
 * both that copyright notice and this permission notice appear in
 * supporting documentation.  UCAR makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 * 
 * Note from the author:
 *
 * Where possible, you are encouraged to follow the GNU General Public
 * License, or at least the spirit of the license, for the distribution and
 * licensing of this software and any derived works.  See
 * http://www.gnu.org/copyleft/gpl.html.
 */

#ifndef _BSPLINEBASE_IFACE_ID
#define _BSPLINEBASE_IFACE_ID "$Id: BSpline.h,v 1.21 2005/05/27 21:16:23 granger Exp $"

#if WIN32
# ifndef BSPLINE_DLL_
#  define BSPLINE_DLL_ __declspec(dllimport)
# endif
#else
# define BSPLINE_DLL_
#endif /* WIN32 */


template <class T> class BSpline;

/*
 * Opaque member structure to hide the matrix implementation.
 */
template <class T> struct BSplineBaseP;

template <class T> 
class BSPLINE_DLL_ BSplineBase  
{
public:
    // Datum type
    typedef T datum_type;

    static const char *ImplVersion();

    static const char *IfaceVersion();
        
    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 &);

    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; }

    virtual ~BSplineBase();

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;
    Base *base;                 // Hide more complicated state members
                                // from the public interface.

    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 &);
};


template <class T> struct BSplineP;


template <class T>
class BSPLINE_DLL_ BSpline : public BSplineBase<T>
{
public:
    BSpline (const T *x, int nx,                /* independent variable */
             const T *y,                        /* dependent values @ ea X */
             double wl,                         /* cutoff wavelength */
             int bc_type = BSplineBase<T>::BC_ZERO_SECOND,
             int num_nodes = 0);

    BSpline (BSplineBase<T> &base, const T *y);

    bool solve (const T *y);

    const T *curve (int *nx = 0);

    T evaluate (T x);

    T slope (T x);

    T coefficient (int n);

    virtual ~BSpline();

    using BSplineBase<T>::Debug;

protected:

    using BSplineBase<T>::OK;
    using BSplineBase<T>::M;
    using BSplineBase<T>::NX;
    using BSplineBase<T>::DX;
    using BSplineBase<T>::base;
    using BSplineBase<T>::xmin;
    using BSplineBase<T>::xmax;

    // Our hidden state structure
    BSplineP<T> *s;
    T mean;                     // Fit without mean and add it in later

};

#endif // !defined _BSPLINEBASE_IFACE_ID

---