SplineFitter.h

Go to the documentation of this file.

#ifndef SimTK_SIMMATH_SPLINE_FITTER_H_
#define SimTK_SIMMATH_SPLINE_FITTER_H_

/* -------------------------------------------------------------------------- *
 *                        Simbody(tm): SimTKmath                              *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK biosimulation toolkit originating from           *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody.  *
 *                                                                            *
 * Portions copyright (c) 2008-12 Stanford University and the Authors.        *
 * Authors: Peter Eastman                                                     *
 * Contributors:                                                              *
 *                                                                            *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may    *
 * not use this file except in compliance with the License. You may obtain a  *
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0.         *
 *                                                                            *
 * Unless required by applicable law or agreed to in writing, software        *
 * distributed under the License is distributed on an "AS IS" BASIS,          *
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   *
 * See the License for the specific language governing permissions and        *
 * limitations under the License.                                             *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon.h"
#include "simmath/internal/common.h"
#include "simmath/internal/Spline.h"
#include "simmath/internal/GCVSPLUtil.h"

namespace SimTK {

template <class T>
class SplineFitter {
public:
    SplineFitter(const SplineFitter& copy) : impl(copy.impl) {
        impl->referenceCount++;
    }
    SplineFitter operator=(const SplineFitter& copy) {
        impl = copy.impl;
        impl->referenceCount++;
        return *this;
    }
    ~SplineFitter() {
        impl->referenceCount--;
        if (impl->referenceCount == 0)
            delete impl;
    }

    static SplineFitter fitFromGCV
       (int degree, const Vector& x, const Vector_<T>& y) {
        Vector_<T> coeff;
        Vector wk;
        int ier;
        GCVSPLUtil::gcvspl(x, y, Vector(x.size(), 1.0), T(1), 
                           degree, 2, 0, coeff, wk, ier);
        return SplineFitter<T>(new SplineFitterImpl
           (degree, Spline_<T>(degree, x, coeff), wk[3], wk[4], wk[2]));
    }

    static SplineFitter fitFromErrorVariance
       (int degree, const Vector& x, const Vector_<T>& y, Real error) {
        Vector_<T> coeff;
        Vector wk;
        int ier;
        GCVSPLUtil::gcvspl(x, y, Vector(x.size(), 1.0), T(1), 
                           degree, 3, error, coeff, wk, ier);
        return SplineFitter<T>(new SplineFitterImpl
           (degree, Spline_<T>(degree, x, coeff), wk[3], wk[4], wk[2]));
    }

    static SplineFitter fitFromDOF
       (int degree, const Vector& x, const Vector_<T>& y, Real dof) {
        Vector_<T> coeff;
        Vector wk;
        int ier;
        GCVSPLUtil::gcvspl(x, y, Vector(x.size(), 1.0), T(1), 
                           degree, 4, dof, coeff, wk, ier);
        return SplineFitter<T>(new SplineFitterImpl
           (degree, Spline_<T>(degree, x, coeff), wk[3], wk[4], wk[2]));
    }

    static SplineFitter fitForSmoothingParameter
       (int degree, const Vector& x, const Vector_<T>& y, Real p) {
        Vector_<T> coeff;
        Vector wk;
        int ier;
        GCVSPLUtil::gcvspl(x, y, Vector(x.size(), 1.0), T(1), 
                           degree, 1, p, coeff, wk, ier);
        return SplineFitter<T>(new SplineFitterImpl
           (degree, Spline_<T>(degree, x, coeff), wk[3], wk[4], wk[2]));
    }
    const Spline_<T>& getSpline() {
        return impl->spline;
    }
    Real getSmoothingParameter() {
        return impl->p;
    }
    Real getMeanSquaredError() {
        return impl->error;
    }
    Real getDegreesOfFreedom() {
        return impl->dof;
    }
private:
    class SplineFitterImpl;
    SplineFitter(SplineFitterImpl *impl) : impl(impl) {
    }
    SplineFitterImpl* impl;
};

template <class T>
class SplineFitter<T>::SplineFitterImpl {
public:
    SplineFitterImpl(int degree, const Spline_<T>& spline, Real p, Real error, Real dof) : referenceCount(1), degree(degree), spline(spline), p(p), error(error), dof(dof) {
    }
    ~SplineFitterImpl() {
        assert(referenceCount == 0);
    }
    int referenceCount;
    int degree;
    Spline_<T> spline;
    Real p, error, dof;
};

} // namespace SimTK

#endif // SimTK_SIMMATH_SPLINE_FITTER_H_