floatarray.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef floatarray_h
#define floatarray_h
 
#include "oofemenv.h"
#include "contextioresulttype.h"
#include "contextmode.h"
#include "error.h"
#include "numerics.h"
 
#include <initializer_list>
#include <vector>
#include <list>
#include <iosfwd>
 
namespace oofem {
class IntArray;
class FloatMatrix;
class DataStream;
template<std::size_t N> class FloatArrayF;

 
 
class OOFEM_EXPORT FloatArray
#ifdef _USE_EIGEN
: public VectorXd
#endif
{
#ifdef _USE_EIGEN
public:
    OOFEM_EIGEN_DERIVED(FloatArray,VectorXd);
    FloatArray(int sz): VectorXd(sz) {}
    void resize(Index s);
#else
 
protected:
    std::vector< double > values;
 
public:

    std::vector< double > :: iterator begin() { return this->values.begin(); }
    std::vector< double > :: iterator end() { return this->values.end(); }
    std::vector< double > :: const_iterator begin() const { return this->values.begin(); }
    std::vector< double > :: const_iterator end() const { return this->values.end(); }
 
    static constexpr int Dim = 1;
    typedef double Scalar;

    FloatArray(int n = 0) : values(n) { }
    FloatArray(double)  = delete;
    FloatArray(const FloatArray &src) : values(src.values) { }
    FloatArray(FloatArray &&src) noexcept : values(std::move(src.values)) { }
    FloatArray &operator = (const FloatArray &src) { values = src.values; return *this; }
    FloatArray &operator = (FloatArray &&src) noexcept { values = std::move(src.values); return *this; }
 
 
    inline const double *data() const { return values.data(); }
    inline double *data() { return values.data(); }
    inline double &operator() (Index i) { return this->operator[](i); }
    inline double &operator[] (Index i)
    {
        #ifndef NDEBUG
            checkBounds(i+1);
        #endif
        return values [ i ];
    }

    inline const double &operator() (Index i) const { return this->operator[](i); }
    inline const double &operator[] (Index i) const {
        #ifndef NDEBUG
            checkBounds(i+1);
        #endif
        return values [ i ];
    }

    void resize(Index s);
    Index size() const { return this->values.size(); }
#endif
    void _resize_internal(Index newsize);
    FloatArray(std :: initializer_list< double >list) { (*this)=fromIniList(list); }
    static FloatArray fromVector(const std::vector<double>& v);
    static FloatArray fromList(const std::list<double>& l);
    static FloatArray fromConcatenated(std::initializer_list<FloatArray> ini);
    static FloatArray fromIniList(std::initializer_list<double> ini);
    template< std::size_t N >
    inline FloatArray( const FloatArrayF<N> &src ) {
        #ifdef _USE_EIGEN
            VectorXd::resize(src.size());
        #else
            values.resize(src.size());
        #endif
        for(Index i=0; i<src.size(); i++) (*this)[i]=src[i];
    }

    virtual ~FloatArray() {}
 

    inline FloatArray &operator = (std :: initializer_list< double >list) { (*this)=fromIniList(list); return *this; }
    template< std::size_t N >
    inline FloatArray &operator = (const FloatArrayF<N> &src){
        this->resize(src.size()); // FIXME: useless zeroing
        for(Index i=0; i<src.size(); i++) (*this)[i]=src[i];
        return *this;
    }

    bool isAllFinite() const;

    inline double &at(Index i)
    {
#ifndef NDEBUG
        this->checkBounds( i );
#endif
        return (*this)[ i - 1 ];
    }

    inline double at(Index i) const
    {
#ifndef NDEBUG
        this->checkBounds( i );
#endif
        return (*this)[ i - 1 ];
    }

    void checkBounds(Index i) const
    {
        if ( i <= 0 ) {
            OOFEM_ERROR("array error on index : %d <= 0", (int)i);
        } else if ( i > size()) {
            OOFEM_ERROR("array error on index : %d > %d", (int)i, (int)this->size());
        }
    }

    void checkSizeTowards(const IntArray &loc);
    void resizeWithValues(Index s, std::size_t allocChunk = 0);
    void clear() { this->resize(0); }
    bool containsOnlyZeroes() const;
    //[[deprecated("use size() instead.")]]
    Index giveSize() const { return this->size(); }
    bool isNotEmpty() const { return size()>0; }
    bool isEmpty() const { return size()==0; }
    void negated();
    virtual void printYourself() const;    
    virtual void printYourself(const std::string &name) const;
    virtual void printYourselfToFile(const std::string filename, const bool showDimensions=true) const;
    virtual void pY() const;
    void zero();
    void beProductOf(const FloatMatrix &aMatrix, const FloatArray &anArray);
    void beTProductOf(const FloatMatrix &aMatrix, const FloatArray &anArray);
    void beVectorProductOf(const FloatArray &v1, const FloatArray &v2);
    void beScaled(double s, const FloatArray &b);
    void add(const FloatArray &src);
    void add(double factor, const FloatArray &b);
    void plusProduct(const FloatMatrix &b, const FloatArray &s, double dV);
    void add(double offset);
    void subtract(const FloatArray &src);
    void times(double s);
    void beMaxOf(const FloatArray &a, const FloatArray &b);
    void beMinOf(const FloatArray &a, const FloatArray &b);
    void beDifferenceOf(const FloatArray &a, const FloatArray &b);
    void beDifferenceOf(const FloatArray &a, const FloatArray &b, Index n);
    void beSubArrayOf(const FloatArray &src, const IntArray &indx);
    void addSubVector(const FloatArray &src, Index si);
    void assemble(const FloatArray &fe, const IntArray &loc);
    void assembleSquared(const FloatArray &fe, const IntArray &loc);
    void copySubVector(const FloatArray &src, int si);
    double distance(const FloatArray &x) const;
    double distance(const FloatArray *x) const { return this->distance(* x); }

    double distance(const FloatArray &iP1, const FloatArray &iP2, double &oXi, double &oXiUnbounded) const;
    double distance_square(const FloatArray &iP1, const FloatArray &iP2, double &oXi, double &oXiUnbounded) const;

    double distance_square(const FloatArray &x) const;

    int giveIndexMinElem(void);

    int giveIndexMaxElem(void);

    double dotProduct(const FloatArray &x) const;

    double dotProduct(const FloatArray &x, Index size) const;

    double normalize_giveNorm();
    void normalize();
    double computeNorm() const;
    double computeSquaredNorm() const;
    double sum() const;
    double product() const;

    void rotatedWith(FloatMatrix &r, char mode);
    inline const double *givePointer() const { return data(); }
    inline double *givePointer() { return data(); }
    void beVectorForm(const FloatMatrix &aMatrix);
    void beSymVectorForm(const FloatMatrix &aMatrix);
    void beSymVectorFormOfStrain(const FloatMatrix &aMatrix);

    void changeComponentOrder();

    void power(const double exponent);

    void beColumnOf(const FloatMatrix &mat, int col);

    void beRowOf(const FloatMatrix &mat, Index row);
    
    contextIOResultType storeYourself(DataStream &stream) const;
    contextIOResultType restoreYourself(DataStream &stream);
    int givePackSize(DataStream &buff) const;
 
    friend std :: ostream &operator << ( std :: ostream & out, const FloatArray & x );
 
    friend class FloatMatrix;



    FloatArray &operator = ( const double & );
};
 
#ifndef _USE_EIGEN

    OOFEM_EXPORT FloatArray &operator *= ( FloatArray & x, const double & a );
    OOFEM_EXPORT FloatArray operator *( const double & a, const FloatArray & x );
    OOFEM_EXPORT FloatArray operator *( const FloatArray & x, const double & a );
    OOFEM_EXPORT FloatArray operator + ( const FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray operator - ( const FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray &operator += ( FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray &operator -= ( FloatArray & x, const FloatArray & y );
#endif
 


#ifndef _USE_EIGEN
    OOFEM_EXPORT FloatArray &operator *= ( FloatArray & x, const double & a );
    OOFEM_EXPORT FloatArray operator *( const double & a, const FloatArray & x );
    OOFEM_EXPORT FloatArray operator *( const FloatArray & x, const double & a );
    //
    OOFEM_EXPORT FloatArray operator / ( const FloatArray & x, const double & a );
    OOFEM_EXPORT FloatArray operator / ( const double & a, const FloatArray & x );
    //
    OOFEM_EXPORT FloatArray operator + ( const FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray operator - ( const FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray &operator += ( FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray &operator -= ( FloatArray & x, const FloatArray & y );
    OOFEM_EXPORT FloatArray &operator /= ( FloatArray & x, const double & a );
#endif
 
  
OOFEM_EXPORT double norm(const FloatArray &x);
OOFEM_EXPORT double norm_square(const FloatArray &x);
OOFEM_EXPORT double dot(const FloatArray &x, const FloatArray &y);
OOFEM_EXPORT double distance(const FloatArray &x, const FloatArray &y);
OOFEM_EXPORT double distance_square(const FloatArray &x, const FloatArray &y);
OOFEM_EXPORT bool isfinite(const FloatArray &x);
OOFEM_EXPORT bool iszero(const FloatArray &x);
OOFEM_EXPORT double sum(const FloatArray & x);
OOFEM_EXPORT double product(const FloatArray & x);
 
 
inline static FloatArray Vec1(const double& a){ return FloatArray::fromIniList({a}); }
inline static FloatArray Vec2(const double& a, const double& b){ return FloatArray::fromIniList({a,b}); }
inline static FloatArray Vec3(const double& a, const double& b, const double& c){ return FloatArray::fromIniList({a,b,c}); }
inline static FloatArray Vec4(const double& a, const double& b, const double& c, const double& d){ return FloatArray::fromIniList({a,b,c,d}); }
inline static FloatArray Vec5(const double& a, const double& b, const double& c, const double& d, const double& e){ return FloatArray::fromIniList({a,b,c,d,e}); }
inline static FloatArray Vec6(const double& a, const double& b, const double& c, const double& d, const double& e, const double& f){ return FloatArray::fromIniList({a,b,c,d,e,f}); }
inline static FloatArray Vec7(const double& a, const double& b, const double& c, const double& d, const double& e, const double& f, const double& g){ return FloatArray::fromIniList({a,b,c,d,e,f,g}); }
inline static FloatArray Vec8(const double& a, const double& b, const double& c, const double& d, const double& e, const double& f, const double& g, const double& h){ return FloatArray::fromIniList({a,b,c,d,e,f,g,h}); }
inline static FloatArray Vec9(const double& a, const double& b, const double& c, const double& d, const double& e, const double& f, const double& g, const double& h, const double& i){ return FloatArray::fromIniList({a,b,c,d,e,f,g,h,i}); }
inline static FloatArray VecX(std::initializer_list<double> ini){ return FloatArray::fromIniList(ini); }

} // end namespace oofem
#endif // floatarray_h