BernsteinPoly.h

//===========================================================================
// GoTools - SINTEF Geometry Tools
//
// GoTools module: Implicitization, version 1.0
//
// Copyright (C) 2000-2007 SINTEF ICT, Applied Mathematics, Norway.
//
// This program is free software; you can redistribute it and/or          
// modify it under the terms of the GNU General Public License            
// as published by the Free Software Foundation version 2 of the License. 
//
// This program is distributed in the hope that it will be useful,        
// but WITHOUT ANY WARRANTY; without even the implied warranty of         
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          
// GNU General Public License for more details.                           
//
// You should have received a copy of the GNU General Public License      
// along with this program; if not, write to the Free Software            
// Foundation, Inc.,                                                      
// 59 Temple Place - Suite 330,                                           
// Boston, MA  02111-1307, USA.                                           
//
// Contact information: E-mail: tor.dokken@sintef.no                      
// SINTEF ICT, Department of Applied Mathematics,                         
// P.O. Box 124 Blindern,                                                 
// 0314 Oslo, Norway.                                                     
//
// Other licenses are also available for this software, notably licenses
// for:
// - Building commercial software.                                        
// - Building software whose source code you wish to keep private.        
//===========================================================================
#ifndef _BERNSTEINPOLY_H
#define _BERNSTEINPOLY_H

#include <vector>
#include <iostream>

namespace Go {



class BernsteinPoly {
public:
    BernsteinPoly() { }
    explicit BernsteinPoly(const std::vector<double>& coefs)
        : coefs_(coefs) { }
    template <typename ForwardIterator>
    BernsteinPoly(ForwardIterator begin, ForwardIterator end)
        : coefs_(begin, end) { }
    explicit BernsteinPoly(double coef)
        : coefs_(std::vector<double>(1, coef)) { }

    int degree() const
    { return coefs_.size() - 1; }

    const double& operator[] (int num) const
    { return coefs_[num]; }
    double& operator[] (int num)
    { return coefs_[num]; }
    std::vector<double>::iterator coefsBegin()
    { return coefs_.begin(); }
    std::vector<double>::const_iterator coefsBegin() const
    { return coefs_.begin(); }
    std::vector<double>::iterator coefsEnd()
    { return coefs_.end(); }
    std::vector<double>::const_iterator coefsEnd() const
    { return coefs_.end(); }

    double operator() (double t) const;

    bool isZero(const double eps = 0.0) const;
    bool isStrictlyPositive(const double eps = 0.0) const;

    double norm() const;
    void normalize();

    BernsteinPoly deriv(int der) const;

    double integral(double a = 0.0, double b = 1.0) const;

    double blossom(const std::vector<double>& tvec) const;
    BernsteinPoly pickInterval(double a, double b) const;

    void degreeElevate(int d);

    BernsteinPoly& operator*= (const BernsteinPoly& poly);
    BernsteinPoly& operator*= (double c);

    BernsteinPoly& operator+= (const BernsteinPoly& poly);
    BernsteinPoly& operator+= (double c);

    BernsteinPoly& operator-= (const BernsteinPoly& poly);
    BernsteinPoly& operator-= (double c);

    BernsteinPoly& operator/= (double c);

    void read(std::istream& is);
    void write(std::ostream& os) const;

private:
    std::vector<double> coefs_;
};


inline BernsteinPoly operator* (const BernsteinPoly& p1,
                                const BernsteinPoly& p2)
{
    BernsteinPoly tmp = p1;
    tmp *= p2;
    return tmp;
}


inline BernsteinPoly operator* (const BernsteinPoly& p,
                                double c)
{
    BernsteinPoly tmp = p;
    tmp *= c;
    return tmp;
}


inline BernsteinPoly operator* (double c,
                                const BernsteinPoly& p)
{
    BernsteinPoly tmp = p;
    tmp *= c;
    return tmp;
}


inline BernsteinPoly operator+ (const BernsteinPoly& p1,
                                const BernsteinPoly& p2)
{
    BernsteinPoly tmp = p1;
    tmp += p2;
    return tmp;
}


inline BernsteinPoly operator+ (double c,
                                const BernsteinPoly& p)
{
    BernsteinPoly tmp = p;
    tmp += c;
    return tmp;
}


inline BernsteinPoly operator+ (const BernsteinPoly& p,
                                double c)
{
    BernsteinPoly tmp = p;
    tmp += c;
    return tmp;
}


inline BernsteinPoly operator- (const BernsteinPoly& p1,
                                const BernsteinPoly& p2)
{
    BernsteinPoly tmp = p1;
    tmp -= p2;
    return tmp;
}


inline BernsteinPoly operator- (double c,
                                const BernsteinPoly& p)
{
    BernsteinPoly tmp(c);
    tmp -= p;
    return tmp;
}


inline BernsteinPoly operator- (const BernsteinPoly& p,
                                double c)
{
    BernsteinPoly tmp = p;
    tmp -= c;
    return tmp;
}


inline BernsteinPoly operator/ (const BernsteinPoly& p,
                                double c)
{
    BernsteinPoly tmp = p;
    tmp /= c;
    return tmp;
}


} // namespace Go


namespace std {



inline std::istream& operator >> (std::istream& is,
                                  Go::BernsteinPoly& p)
{
    p.read(is);
    return is;
}


inline std::ostream& operator << (std::ostream& os,
                                  const Go::BernsteinPoly& p)
{
    p.write(os);
    return os;
}


} // namespace std


#endif // _BERNSTEINPOLY_H

---