intarray.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 intarray_h
#define intarray_h
 
#include "oofemenv.h"
#include "contextioresulttype.h"
#include "contextmode.h"
#include "error.h"
 
#include <cstdio>
#include <vector>
#include <iosfwd>
#include <initializer_list>
 
namespace oofem {
class DataStream;

class OOFEM_EXPORT IntArray
{
private:
    std::vector< int > values;
 
public:

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

    IntArray(int n = 0) : values(n) { }
    IntArray(const IntArray &src) : values(src.values) { }
    IntArray(IntArray &&src) noexcept : values(std::move(src.values)) { }
    inline IntArray(std :: initializer_list< int >list) : values(list) { }
    ~IntArray() {};

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

    inline int &at(std::size_t i)
    {
#ifndef NDEBUG
        this->checkBounds(i);
#endif
        return values[ i - 1 ];
    }

    inline int at(std::size_t i) const
    {
#ifndef NDEBUG
        this->checkBounds(i);
#endif
        return values[ i - 1 ];
    }

    inline int &operator() (std::size_t i) { return this->operator[](i); }
    inline int &operator[] (std::size_t i)
    {
#ifndef NDEBUG
        this->checkBounds(i + 1);
#endif
        return values[ i ];
    }

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

    void checkBounds(std::size_t i) const
    {
        if ( i <= 0 ) {
            OOFEM_ERROR("array error on index : %ld <= 0", i);
        } else if ( i > values.size()) {
            OOFEM_ERROR("array error on index : %ld > %d", i, this->giveSize());
        }
    }

    void resizeWithValues(int n, int allocChunk = 0);
    void resize(int n);
    void clear() { this->values.clear(); }
    void preallocate(int futureSize);
    void enumerate(int maxVal);
    void followedBy(const IntArray &b, int allocChunk = 0);
    void followedBy(int b, int allocChunk = 0);
    int giveSize() const { return (int)values.size(); }
    std::size_t size() const { return values.size(); }
    bool isEmpty() const { return values.size() == 0; }
    bool containsOnlyZeroes() const;
    int findSorted(int value) const;
    int minimum() const;
    int maximum() const;
    void findNonzeros(const IntArray &logical);
    bool containsSorted(int value) const { return ( findSorted(value) > 0 ); }

    void insertSorted(int value, int allocChunk = 0);
    bool insertSortedOnce(int value, int allocChunk = 0);
    void eraseSorted(int value);
    int findCommonValuesSorted(const IntArray &iarray, IntArray &common, int allocChunk = 0) const;

    int findFirstIndexOf(int value) const;
    bool contains(int value) const { return ( findFirstIndexOf(value) > 0 ); }
    void insertOnce(int p);
    void sort();
    void erase(int pos);
    void add(int val);

    void zero();

    void printYourself() const;

    void pY() const;

    void printYourself(const std::string name) const;

    void printYourselfToFile(const std::string filename, const bool showDimensions=true) const;

    bool isAllFinite() const;

    inline const int *givePointer() const { return values.data(); }
    inline int *givePointer() { return values.data(); }

    contextIOResultType storeYourself(DataStream &stream) const;
    contextIOResultType restoreYourself(DataStream &stream);
    int givePackSize(DataStream &buff) const;
 
 
    friend std :: ostream &operator << ( std :: ostream & out, const IntArray & x );
 
    std::vector<int> minusOne() const { std::vector<int> ret(values.size()); for(size_t i=0; i<values.size(); i++) ret[i]=values[i]-1; return ret; }
};
 
 
template< class operation > int
quickSortPartition(IntArray &arry, int l, int r, operation op)
{
    int i = l - 1, j = r;
    int v = arry.at(r);
    int swap;
 
    for ( ; ; ) {
        while ( ( op(arry.at(++i), v) ) < 0 ) {
            ;
        }
 
        while ( ( op( v, arry.at(--j) ) ) < 0 ) {
            if ( j == l ) {
                break;
            }
        }
 
        if ( i >= j ) {
            break;
        }
 
        swap = arry.at(i);
        arry.at(i) = arry.at(j);
        arry.at(j) = swap;
    }
 
    swap = arry.at(i);
    arry.at(i) = arry.at(r);
    arry.at(r) = swap;
    return i;
}
 
 
 
template< class operation > void quickSort(IntArray &arry, int l, int r, operation op)
{
    if ( r <= l ) {
        return;
    }
 
    int i = quickSortPartition(arry, l, r, op);
    quickSort(arry, l, i - 1, op);
    quickSort(arry, i + 1, r, op);
}
 

template< class operation > void sort(IntArray &arry, operation op) { quickSort(arry, 1, arry.giveSize(), op); }
} // end namespace oofem
#endif // intarray_h