0,0 → 1,107 |
// Explicit instantiation file. |
|
// Copyright (C) 2001-2013 Free Software Foundation, Inc. |
// |
// This file is part of the GNU ISO C++ Library. This library is free |
// software; you can redistribute it and/or modify it under the |
// terms of the GNU General Public License as published by the |
// Free Software Foundation; either version 3, or (at your option) |
// any later version. |
|
// This library 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 General Public License for more details. |
|
// Under Section 7 of GPL version 3, you are granted additional |
// permissions described in the GCC Runtime Library Exception, version |
// 3.1, as published by the Free Software Foundation. |
|
// You should have received a copy of the GNU General Public License and |
// a copy of the GCC Runtime Library Exception along with this program; |
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see |
// <http://www.gnu.org/licenses/>. |
|
// |
// ISO C++ 14882: |
// |
|
#include <valarray> |
|
namespace std _GLIBCXX_VISIBILITY(default) |
{ |
_GLIBCXX_BEGIN_NAMESPACE_VERSION |
|
// Some explicit instantiations. |
template void |
__valarray_fill(size_t* __restrict__, size_t, const size_t&); |
|
template void |
__valarray_copy(const size_t* __restrict__, size_t, size_t* __restrict__); |
|
template valarray<size_t>::valarray(size_t); |
template valarray<size_t>::valarray(const valarray<size_t>&); |
template valarray<size_t>::~valarray(); |
template size_t valarray<size_t>::size() const; |
template size_t& valarray<size_t>::operator[](size_t); |
|
inline size_t |
__valarray_product(const valarray<size_t>& __a) |
{ |
const size_t __n = __a.size(); |
// XXX: This ugly cast is necessary because |
// valarray::operator[]() const return a VALUE! |
// Try to get the committee to correct that gross error. |
valarray<size_t>& __t = const_cast<valarray<size_t>&>(__a); |
return __valarray_product(&__t[0], &__t[0] + __n); |
} |
|
// Map a gslice, described by its multidimensional LENGTHS |
// and corresponding STRIDES, to a linear array of INDEXES |
// for the purpose of indexing a flat, one-dimensional array |
// representation of a gslice_array. |
void |
__gslice_to_index(size_t __o, const valarray<size_t>& __l, |
const valarray<size_t>& __s, valarray<size_t>& __i) |
{ |
// There are as many dimensions as there are strides. |
const size_t __n = __l.size(); |
|
// Holds current multi-index as we go through the gslice for the |
// purpose of computing its linear-image. |
valarray<size_t> __t(__l); |
|
// Note that this should match the product of all numbers appearing |
// in __l which describes the multidimensional sizes of the |
// generalized slice. |
const size_t __z = __i.size(); |
|
for (size_t __j = 0; __j < __z; ++__j) |
{ |
// Compute the linear-index image of (t_0, ... t_{n-1}). |
__i[__j] = __o; |
|
--__t[__n - 1]; |
__o += __s[__n - 1]; |
|
// Process the next multi-index. The loop ought to be |
// backward since we're making a lexicographical visit. |
for (size_t __k2 = __n - 1; __k2 && !__t[__k2]; --__k2) |
{ |
__o -= __s[__k2] * __l[__k2]; |
__t[__k2] = __l[__k2]; |
|
--__t[__k2 - 1]; |
__o += __s[__k2 - 1]; |
} |
} |
} |
|
gslice::_Indexer::_Indexer(size_t __o, const valarray<size_t>& __l, |
const valarray<size_t>& __s) |
: _M_count(1), _M_start(__o), _M_size(__l), _M_stride(__s), |
_M_index(__l.size() == 0 ? 0 : __valarray_product(__l)) |
{ __gslice_to_index(__o, __l, __s, _M_index); } |
|
_GLIBCXX_END_NAMESPACE_VERSION |
} // namespace |