intarray.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 intarray_h
#define intarray_h

#include "oofemcfg.h"
#include "contextioresulttype.h"
#include "contextmode.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(); }

    IntArray(int n = 0) : values(n) { }
    IntArray(const IntArray &src) : values(src.values) { }
    IntArray(IntArray &&src) : 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) { values = std::move(src.values); return *this; }
    inline IntArray &operator = (std :: initializer_list< int >list) { values = list; return *this; }

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

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

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

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

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

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

#ifdef DEBUG

    void checkBounds(int i) const;
#endif

    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(); }
    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 isFinite() 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 );

#ifdef BOOST_PYTHON
    void __setitem__(int i, int val) { this->at(i + 1) = val; }
    int __getitem__(int i) { return this->at(i + 1); }
    void beCopyOf(const IntArray &src) { this->operator = ( src ); }
#endif
};


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