160 lines
3.1 KiB
C++
160 lines
3.1 KiB
C++
// Copyright (c) 2010, Lawrence Livermore National Security, LLC. Produced at
|
|
// the Lawrence Livermore National Laboratory. LLNL-CODE-443211. All Rights
|
|
// reserved. See file COPYRIGHT for details.
|
|
//
|
|
// This file is part of the MFEM library. For more information and source code
|
|
// availability see http://mfem.googlecode.com.
|
|
//
|
|
// MFEM 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) version 2.1 dated February 1999.
|
|
|
|
|
|
// Abstract array data type
|
|
|
|
#include "array.hpp"
|
|
|
|
namespace mfem
|
|
{
|
|
|
|
BaseArray::BaseArray(int asize, int ainc, int elementsize)
|
|
{
|
|
if (asize > 0)
|
|
{
|
|
data = new char[asize * elementsize];
|
|
size = allocsize = asize;
|
|
}
|
|
else
|
|
{
|
|
data = 0;
|
|
size = allocsize = 0;
|
|
}
|
|
inc = ainc;
|
|
}
|
|
|
|
BaseArray::~BaseArray()
|
|
{
|
|
if (allocsize > 0)
|
|
delete [] (char*)data;
|
|
}
|
|
|
|
void BaseArray::GrowSize(int minsize, int elementsize)
|
|
{
|
|
void *p;
|
|
int nsize = (inc > 0) ? abs(allocsize) + inc : 2 * abs(allocsize);
|
|
if (nsize < minsize) nsize = minsize;
|
|
|
|
p = new char[nsize * elementsize];
|
|
if (size > 0)
|
|
memcpy(p, data, size * elementsize);
|
|
if (allocsize > 0)
|
|
delete [] (char*)data;
|
|
data = p;
|
|
allocsize = nsize;
|
|
}
|
|
|
|
template <class T>
|
|
void Array<T>::Print(std::ostream &out, int width)
|
|
{
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
out << ((T*)data)[i];
|
|
if ( !((i+1) % width) || i+1 == size )
|
|
out << '\n';
|
|
else
|
|
out << " ";
|
|
}
|
|
}
|
|
|
|
template <class T>
|
|
void Array<T>::Save(std::ostream &out)
|
|
{
|
|
out << size << '\n';
|
|
for (int i = 0; i < size; i++)
|
|
out << operator[](i) << '\n';
|
|
}
|
|
|
|
template <class T>
|
|
T Array<T>::Max() const
|
|
{
|
|
MFEM_ASSERT(size > 0, "Array is empty with size " << size);
|
|
|
|
T max = operator[](0);
|
|
for (int i = 1; i < size; i++)
|
|
if (max < operator[](i))
|
|
max = operator[](i);
|
|
|
|
return max;
|
|
}
|
|
|
|
template <class T>
|
|
T Array<T>::Min() const
|
|
{
|
|
MFEM_ASSERT(size > 0, "Array is empty with size " << size);
|
|
|
|
T min = operator[](0);
|
|
for (int i = 1; i < size; i++)
|
|
if (operator[](i) < min)
|
|
min = operator[](i);
|
|
|
|
return min;
|
|
}
|
|
|
|
template <class T>
|
|
int Compare(const void *p, const void *q)
|
|
{
|
|
if (*((T*)p) < *((T*)q)) return -1;
|
|
if (*((T*)q) < *((T*)p)) return +1;
|
|
return 0;
|
|
}
|
|
|
|
template <class T>
|
|
void Array<T>::Sort()
|
|
{
|
|
// qsort((T*)data,0,size-1);
|
|
qsort(data, size, sizeof(T), Compare<T>); // use qsort from stdlib.h
|
|
}
|
|
|
|
// Partial Sum
|
|
template <class T>
|
|
void Array<T>::PartialSum()
|
|
{
|
|
T sum = static_cast<T>(0);
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
sum+=operator[](i);
|
|
operator[](i) = sum;
|
|
}
|
|
}
|
|
|
|
// Sum
|
|
template <class T>
|
|
T Array<T>::Sum()
|
|
{
|
|
T sum = static_cast<T>(0);
|
|
for (int i = 0; i < size; i++)
|
|
sum+=operator[](i);
|
|
|
|
return sum;
|
|
}
|
|
|
|
template <class T>
|
|
int Array<T>::IsSorted()
|
|
{
|
|
T val_prev = operator[](0), val;
|
|
for (int i = 1; i < size; i++)
|
|
{
|
|
val=operator[](i);
|
|
if (val < val_prev)
|
|
return 0;
|
|
val_prev = val;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
template class Array<int>;
|
|
template class Array<double>;
|
|
|
|
}
|