floatarray.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   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 "oofemcfg.h"
#include "contextioresulttype.h"
#include "contextmode.h"

#include <initializer_list>
#include <vector>
#include <iosfwd>

namespace oofem {
class IntArray;
class FloatMatrix;
class DataStream;

class OOFEM_EXPORT FloatArray
{
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(); }

    FloatArray(int n = 0) : values(n) { }
    FloatArray(double)  = delete;
    FloatArray(const FloatArray &src) : values(src.values) { }
    FloatArray(FloatArray &&src) : values(std::move(src.values)) { }
    inline FloatArray(std :: initializer_list< double >list) : values(list) { }
    virtual ~FloatArray() {};

    FloatArray &operator = (const FloatArray &src) { values = src.values; return *this; }
    FloatArray &operator = (FloatArray &&src) { values = std::move(src.values); return *this; }
    inline FloatArray &operator = (std :: initializer_list< double >list) { values = list; return *this; }

    void push_back(const double &iVal) {values.push_back(iVal);}

    bool isFinite() const;

#ifdef DEBUG
    double &at(int i);
#else
    inline double &at(int i) { return values [ i - 1 ]; }
#endif

#ifdef DEBUG
    double at(int i) const;
#else
    inline double at(int i) const { return values [ i - 1 ]; }
#endif

#ifdef DEBUG
    double &operator() (int i);
    double &operator[] (int i);
#else
    inline double &operator() (int i) {
        return values [ i ];
    };
    inline double &operator[] (int i) {
        return values [ i ];
    };
#endif

#ifdef DEBUG
    const double &operator() (int i) const;
    const double &operator[] (int i) const;
#else
    inline const double &operator() (int i) const { return values [ i ]; }
    inline const double &operator[] (int i) const { return values [ i ]; }
#endif

    void checkBounds(int i) const;
    void checkSizeTowards(const IntArray &loc);
    void reserve(int s);
    void resizeWithValues(int s, int allocChunk = 0);
    void resize(int s);
    void clear() { this->values.clear(); }
    void hardResize(int s);
    bool containsOnlyZeroes() const;
    int giveSize() const { return (int)this->values.size(); }
    bool isNotEmpty() const { return !this->values.empty(); }
    bool isEmpty() const { return this->values.empty(); }
    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 append(const FloatArray &a);
    void append(double a);
    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, int n);
    void beSubArrayOf(const FloatArray &src, const IntArray &indx);
    void addSubVector(const FloatArray &src, int 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, int size) const;

    double 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 values.data(); }
    inline double *givePointer() { return values.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);

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

#ifdef BOOST_PYTHON
    void __setitem__(int i, double val) { this->values[i] = val; }
    double __getitem__(int i) { return this->values[i]; }
    void beCopyOf(const FloatArray &src) { this->operator = ( src ); }
#endif
};

const FloatArray ZeroVector = {0.0,0.0,0.0};


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

double norm(const FloatArray &x);
double dot(const FloatArray &x, const FloatArray &y);
} // end namespace oofem
#endif // floatarray_h