1 : /* GRAPHITE2 LICENSING
2 :
3 : Copyright 2010, SIL International
4 : All rights reserved.
5 :
6 : This library is free software; you can redistribute it and/or modify
7 : it under the terms of the GNU Lesser General Public License as published
8 : by the Free Software Foundation; either version 2.1 of License, or
9 : (at your option) any later version.
10 :
11 : This program is distributed in the hope that it will be useful,
12 : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : Lesser General Public License for more details.
15 :
16 : You should also have received a copy of the GNU Lesser General Public
17 : License along with this library in the file named "LICENSE".
18 : If not, write to the Free Software Foundation, 51 Franklin Street,
19 : Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
20 : internet at http://www.fsf.org/licenses/lgpl.html.
21 :
22 : Alternatively, the contents of this file may be used under the terms of the
23 : Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
24 : License, as published by the Free Software Foundation, either version 2
25 : of the License or (at your option) any later version.
26 : */
27 :
28 : #include "inc/Sparse.h"
29 :
30 : using namespace graphite2;
31 :
32 : namespace
33 : {
34 : template<typename T>
35 0 : inline unsigned int bit_set_count(T v)
36 : {
37 0 : v = v - ((v >> 1) & T(~T(0)/3)); // temp
38 0 : v = (v & T(~T(0)/15*3)) + ((v >> 2) & T(~T(0)/15*3)); // temp
39 0 : v = (v + (v >> 4)) & T(~T(0)/255*15); // temp
40 0 : return (T)(v * T(~T(0)/255)) >> (sizeof(T)-1)*8; // count
41 : }
42 : }
43 :
44 :
45 0 : sparse::~sparse() throw()
46 : {
47 0 : free(m_array.values);
48 0 : }
49 :
50 :
51 0 : sparse::value sparse::operator [] (int k) const throw()
52 : {
53 0 : bool g = k < m_nchunks*SIZEOF_CHUNK; // This will be 0 is were out of bounds
54 0 : k *= g; // Force k to 0 if out of bounds making the map look up safe
55 0 : const chunk & c = m_array.map[k/SIZEOF_CHUNK];
56 0 : const mask_t m = c.mask >> (SIZEOF_CHUNK - 1 - (k%SIZEOF_CHUNK));
57 0 : g *= m & 1; // Extend the guard value to consider the residency bit
58 :
59 0 : return g*m_array.values[c.offset + g*bit_set_count(m >> 1)];
60 : }
61 :
62 :
63 0 : size_t sparse::size() const throw()
64 : {
65 0 : size_t n = m_nchunks,
66 0 : s = 0;
67 :
68 0 : for (const chunk *ci=m_array.map; n; --n, ++ci)
69 0 : s += bit_set_count(ci->mask);
70 :
71 0 : return s;
72 : }
|