~ubuntu-branches/ubuntu/trusty/bmagic/trusty

<h1>bmalgo_impl.h</h1><a href="a00086.html">Go to the documentation of this file.</a><div class="fragment"><pre class="fragment"><a name="l00001"></a>00001 #ifndef BMALGO_IMPL__H__INCLUDED__

<a name="l00002"></a>00002 #define BMALGO_IMPL__H__INCLUDED__

<a name="l00003"></a>00003 /*

<a name="l00005"></a>00005

<a name="l00006"></a>00006 Permission is hereby granted, free of charge, to any person

<a name="l00007"></a>00007 obtaining a copy of this software and associated documentation

<a name="l00008"></a>00008 files (the "Software"), to deal in the Software without restriction,

<a name="l00009"></a>00009 including without limitation the rights to use, copy, modify, merge,

<a name="l00010"></a>00010 publish, distribute, sublicense, and/or sell copies of the Software,

<a name="l00011"></a>00011 and to permit persons to whom the Software is furnished to do so,

<a name="l00012"></a>00012 subject to the following conditions:

<a name="l00013"></a>00013

<a name="l00014"></a>00014 The above copyright notice and this permission notice shall be included

<a name="l00015"></a>00015 in all copies or substantial portions of the Software.

<a name="l00016"></a>00016

<a name="l00017"></a>00017 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

<a name="l00018"></a>00018 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

<a name="l00019"></a>00019 OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

<a name="l00020"></a>00020 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

<a name="l00021"></a>00021 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

<a name="l00022"></a>00022 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

<a name="l00023"></a>00023 OTHER DEALINGS IN THE SOFTWARE.

<a name="l00024"></a>00024

<a name="l00025"></a>00025 For more information please visit: http://bmagic.sourceforge.net

<a name="l00026"></a>00026

<a name="l00027"></a>00027 */

<a name="l00028"></a>00028

<a name="l00029"></a>00029 #ifdef _MSC_VER

<a name="l00030"></a>00030 #pragma warning( disable : 4311 4312)

<a name="l00031"></a>00031 #endif

<a name="l00032"></a>00032

<a name="l00033"></a>00033 #include "<a class="code" href="a00089.html">bmdef.h</a>"

<a name="l00034"></a>00034

<a name="l00035"></a>00035 namespace bm

<a name="l00036"></a>00036 {

<a name="l00037"></a>00037

<a name="l00038"></a>00038 /*! \defgroup setalgo Set algorithms

<a name="l00039"></a>00039 * Set algorithms

<a name="l00040"></a>00040 * \ingroup bmagic

<a name="l00041"></a>00041 */

<a name="l00042"></a>00042

<a name="l00043"></a>00043 /*! \defgroup distance Distance metrics

<a name="l00044"></a>00044 * Algorithms to compute binary distance metrics

<a name="l00045"></a>00045 * \ingroup setalgo

<a name="l00046"></a>00046 */

<a name="l00047"></a>00047

<a name="l00048"></a>00048

<a name="l00049"></a>00049 /*!

<a name="l00050"></a>00050 \brief Distance metrics codes defined for vectors A and B

<a name="l00051"></a>00051 \ingroup distance

<a name="l00052"></a>00052 */

<a name="l00053"></a><a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab">00053</a> enum <a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a>

<a name="l00054"></a>00054 {

<a name="l00055"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce">00055</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">COUNT_AND</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a378be4b14cee6a341e859fd3157ab959">set_COUNT_AND</a>, //!< (A & B).count()

<a name="l00056"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061">00056</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">COUNT_XOR</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a1373054e4f243dffb762a55b8a8bfe4c">set_COUNT_XOR</a>, //!< (A ^ B).count()

<a name="l00057"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb">00057</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">COUNT_OR</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a27e34c148d06e3d8a405482d820cd7fb">set_COUNT_OR</a>, //!< (A | B).count()

<a name="l00058"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62">00058</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">COUNT_SUB_AB</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a0028cc7084b37fe66ce5ae459b93b7f1">set_COUNT_SUB_AB</a>, //!< (A - B).count()

<a name="l00059"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400">00059</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">COUNT_SUB_BA</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a2f7b894c11c058598d02722a7eeef03b">set_COUNT_SUB_BA</a>, //!< (B - A).count()

<a name="l00060"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2">00060</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">COUNT_A</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109abafe8a971864164aeec7f43d1205ed29">set_COUNT_A</a>, //!< A.count()

<a name="l00061"></a><a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516">00061</a> <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">COUNT_B</a> = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a2ac4eb7f41d00f8387d5dd3ffb9d0617">set_COUNT_B</a> //!< B.count()

<a name="l00062"></a>00062 };

<a name="l00063"></a>00063

<a name="l00064"></a>00064 /**

<a name="l00065"></a>00065 Convert set operation into compatible distance metric

<a name="l00066"></a>00066 \ingroup distance

<a name="l00067"></a>00067 */

<a name="l00068"></a>00068 inline

<a name="l00069"></a><a class="code" href="a00120.html#ga158946ea41ca66c3e1bca62c92684788">00069</a> <a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a> <a class="code" href="a00120.html#ga158946ea41ca66c3e1bca62c92684788" title="Convert set operation into compatible distance metric.">operation2metric</a>(<a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109" title="Nomenclature of set operations.">set_operation</a> op)

<a name="l00070"></a>00070 {

<a name="l00071"></a>00071 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(<a class="code" href="a00110.html#a3deb310cdf11bca948817f94adfec160" title="Returns true if set operation is constant (bitcount).">is_const_set_operation</a>(op));

<a name="l00072"></a>00072 if (op == <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a3f165b7944e33214e8721aaf2eb8378e">set_COUNT</a>) op = <a class="code" href="a00110.html#a76b70d2b9182a6dcac151d1bd9ec6109a2ac4eb7f41d00f8387d5dd3ffb9d0617">set_COUNT_B</a>;

100

<a name="l00073"></a>00073 // distance metric is created as a set operation sub-class

101

<a name="l00074"></a>00074 // simple cast will work to convert

102

<a name="l00075"></a>00075 return (<a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a>) op;

103

<a name="l00076"></a>00076 }

104

<a name="l00077"></a>00077

105

<a name="l00078"></a>00078 /*!

106

<a name="l00079"></a>00079 \brief Distance metric descriptor, holds metric code and result.

107

<a name="l00080"></a>00080 \sa distance_operation

108

<a name="l00081"></a>00081 */

109

<a name="l00082"></a>00082

110

<a name="l00083"></a><a class="code" href="a00060.html">00083</a> struct <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>

111

<a name="l00084"></a>00084 {

112

<a name="l00085"></a><a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">00085</a> <a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a> <a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>;

113

<a name="l00086"></a><a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">00086</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

114

<a name="l00087"></a>00087

115

<a name="l00088"></a><a class="code" href="a00060.html#ab4cc0e59d35431f9a6fe110b7a1392df">00088</a> <a class="code" href="a00060.html#a33061afe75bacd27a76abdcffbba65d5">distance_metric_descriptor</a>(<a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a> m)

116

<a name="l00089"></a>00089 : <a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>(m),

117

<a name="l00090"></a>00090 <a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>(0)

118

<a name="l00091"></a>00091 {}

119

<a name="l00092"></a><a class="code" href="a00060.html#a33061afe75bacd27a76abdcffbba65d5">00092</a> <a class="code" href="a00060.html#a33061afe75bacd27a76abdcffbba65d5">distance_metric_descriptor</a>()

120

<a name="l00093"></a>00093 : <a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>(bm::<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">COUNT_XOR</a>),

121

<a name="l00094"></a>00094 <a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>(0)

122

<a name="l00095"></a>00095 {}

123

<a name="l00096"></a>00096

124

<a name="l00097"></a>00097 /*!

125

<a name="l00098"></a>00098 \brief Sets metric result to 0

126

<a name="l00099"></a>00099 */

127

<a name="l00100"></a><a class="code" href="a00060.html#a30de8a19da0c250c3d3645eb51ea942c">00100</a> void <a class="code" href="a00060.html#a30de8a19da0c250c3d3645eb51ea942c" title="Sets metric result to 0.">reset</a>()

128

<a name="l00101"></a>00101 {

129

<a name="l00102"></a>00102 <a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> = 0;

130

<a name="l00103"></a>00103 }

131

<a name="l00104"></a>00104 };

132

<a name="l00105"></a>00105

133

<a name="l00106"></a>00106

134

<a name="l00107"></a>00107 /*!

135

<a name="l00108"></a>00108 \brief Internal function computes different distance metrics.

136

<a name="l00109"></a>00109 \internal

137

<a name="l00110"></a>00110 \ingroup distance

138

<a name="l00111"></a>00111

139

<a name="l00112"></a>00112 */

140

<a name="l00113"></a>00113 inline

141

<a name="l00114"></a><a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a">00114</a> void <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

142

<a name="l00115"></a>00115 unsigned gap,

143

<a name="l00116"></a>00116 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

144

<a name="l00117"></a>00117 int arg_gap,

145

<a name="l00118"></a>00118 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk,

146

<a name="l00119"></a>00119 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit,

147

<a name="l00120"></a>00120 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit_end)

148

<a name="l00121"></a>00121

149

<a name="l00122"></a>00122 {

150

<a name="l00123"></a>00123 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* res=0;

151

<a name="l00124"></a>00124

152

<a name="l00125"></a>00125 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* g1 = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

153

<a name="l00126"></a>00126 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* g2 = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk);

154

<a name="l00127"></a>00127

155

<a name="l00128"></a>00128 if (gap) // first block GAP-type

156

<a name="l00129"></a>00129 {

157

<a name="l00130"></a>00130 if (arg_gap) // both blocks GAP-type

158

<a name="l00131"></a>00131 {

159

<a name="l00132"></a>00132 // TODO: optimize to avoid temp

160

<a name="l00133"></a>00133 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00110.html#a9b1715d6d9164d56172e75bbbd0e3000">bm::gap_equiv_len</a> * 3]; // temporary result

161

<a name="l00134"></a>00134

162

<a name="l00135"></a>00135 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

163

<a name="l00136"></a>00136 {

164

<a name="l00137"></a>00137 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

165

<a name="l00138"></a>00138 unsigned dsize = 0;

166

<a name="l00139"></a>00139

167

<a name="l00140"></a>00140 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

168

<a name="l00141"></a>00141 {

169

<a name="l00142"></a>00142 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

170

<a name="l00143"></a>00143 res = <a class="code" href="a00114.html#ga1666464d22f7fd473db9aafcf2f77a63" title="GAP AND operation.">gap_operation_and</a>(g1, g2, tmp_buf, dsize);

171

<a name="l00144"></a>00144 break;

172

<a name="l00145"></a>00145 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

173

<a name="l00146"></a>00146 res = <a class="code" href="a00114.html#gacda280af8910ae5fde37731a3a7a1226" title="GAP OR operation.">gap_operation_or</a>(g1, g2, tmp_buf, dsize);

174

<a name="l00147"></a>00147 break;

175

<a name="l00148"></a>00148 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

176

<a name="l00149"></a>00149 res = <a class="code" href="a00114.html#gabe4c83e5e162c38e297116dd1cd05ac4" title="GAP SUB (AND NOT) operation.">gap_operation_sub</a>(g1, g2, tmp_buf, dsize);

177

<a name="l00150"></a>00150 break;

178

<a name="l00151"></a>00151 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

179

<a name="l00152"></a>00152 res = <a class="code" href="a00114.html#gabe4c83e5e162c38e297116dd1cd05ac4" title="GAP SUB (AND NOT) operation.">gap_operation_sub</a>(g2, g1, tmp_buf, dsize);

180

<a name="l00153"></a>00153 break;

181

<a name="l00154"></a>00154 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

182

<a name="l00155"></a>00155 res = <a class="code" href="a00114.html#gaa5e07ad0256bf784ad3397acbbd23bb2" title="GAP XOR operation.">gap_operation_xor</a>(g1, g2, tmp_buf, dsize);

183

<a name="l00156"></a>00156 break;

184

<a name="l00157"></a>00157 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

185

<a name="l00158"></a>00158 res = g1;

186

<a name="l00159"></a>00159 break;

187

<a name="l00160"></a>00160 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

188

<a name="l00161"></a>00161 res = g2;

189

<a name="l00162"></a>00162 break;

190

<a name="l00163"></a>00163 } // switch

191

<a name="l00164"></a>00164

192

<a name="l00165"></a>00165 if (res)

193

<a name="l00166"></a>00166 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(res, dsize);

194

<a name="l00167"></a>00167

195

<a name="l00168"></a>00168 } // for it

196

<a name="l00169"></a>00169

197

<a name="l00170"></a>00170 return;

198

<a name="l00171"></a>00171

199

<a name="l00172"></a>00172 }

200

<a name="l00173"></a>00173 else // first block - GAP, argument - BITSET

201

<a name="l00174"></a>00174 {

202

<a name="l00175"></a>00175 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

203

<a name="l00176"></a>00176 {

204

<a name="l00177"></a>00177 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

205

<a name="l00178"></a>00178

206

<a name="l00179"></a>00179 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

207

<a name="l00180"></a>00180 {

208

<a name="l00181"></a>00181 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

209

<a name="l00182"></a>00182 if (arg_blk)

210

<a name="l00183"></a>00183 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gab87384cbf46a04d86c008ab2463d02cc" title="Compute bitcount of bit block AND masked by GAP block.">gap_bitset_and_count</a>(arg_blk, g1);

211

<a name="l00184"></a>00184 break;

212

<a name="l00185"></a>00185 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

213

<a name="l00186"></a>00186 if (!arg_blk)

214

<a name="l00187"></a>00187 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g1);

215

<a name="l00188"></a>00188 else

216

<a name="l00189"></a>00189 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#ga23733890861063a59f787e26763a734a" title="Compute bitcount of bit block OR masked by GAP block.">gap_bitset_or_count</a>(arg_blk, g1);

217

<a name="l00190"></a>00190 break;

218

<a name="l00191"></a>00191 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

219

<a name="l00192"></a>00192 <a class="code" href="a00114.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) temp_blk, g1);

220

<a name="l00193"></a>00193 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

221

<a name="l00194"></a>00194 <a class="code" href="a00115.html#gaabb39bf01bf973cb7bf3648873921ab7" title="Performs bitblock SUB operation and calculates bitcount of the result.">bit_operation_sub_count</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

222

<a name="l00195"></a>00195 ((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk) + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>,

223

<a name="l00196"></a>00196 arg_blk);

224

<a name="l00197"></a>00197

225

<a name="l00198"></a>00198 break;

226

<a name="l00199"></a>00199 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

227

<a name="l00200"></a>00200 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>; // recursive call to SUB_AB

228

<a name="l00201"></a>00201 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(arg_blk,

229

<a name="l00202"></a>00202 arg_gap,

230

<a name="l00203"></a>00203 blk,

231

<a name="l00204"></a>00204 gap,

232

<a name="l00205"></a>00205 temp_blk,

233

<a name="l00206"></a>00206 it, it+1);

234

<a name="l00207"></a>00207 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>; // restore status quo

235

<a name="l00208"></a>00208 break;

236

<a name="l00209"></a>00209 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

237

<a name="l00210"></a>00210 if (!arg_blk)

238

<a name="l00211"></a>00211 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g1);

239

<a name="l00212"></a>00212 else

240

<a name="l00213"></a>00213 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#ga803fbc7c790f07b14175303e524bd2d8" title="Compute bitcount of bit block XOR masked by GAP block.">gap_bitset_xor_count</a>(arg_blk, g1);

241

<a name="l00214"></a>00214 break;

242

<a name="l00215"></a>00215 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

243

<a name="l00216"></a>00216 if (g1)

244

<a name="l00217"></a>00217 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g1);

245

<a name="l00218"></a>00218 break;

246

<a name="l00219"></a>00219 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

247

<a name="l00220"></a>00220 if (arg_blk)

248

<a name="l00221"></a>00221 {

249

<a name="l00222"></a>00222 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

250

<a name="l00223"></a>00223 <a class="code" href="a00115.html#gab30df14a61f036d690c091878feaff1c" title="Bitcount for bit string.">bit_block_calc_count</a>(arg_blk,

251

<a name="l00224"></a>00224 arg_blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

252

<a name="l00225"></a>00225 }

253

<a name="l00226"></a>00226 break;

254

<a name="l00227"></a>00227 } // switch

255

<a name="l00228"></a>00228

256

<a name="l00229"></a>00229 } // for it

257

<a name="l00230"></a>00230

258

<a name="l00231"></a>00231 return;

259

<a name="l00232"></a>00232

260

<a name="l00233"></a>00233 }

261

<a name="l00234"></a>00234 }

262

<a name="l00235"></a>00235 else // first block is BITSET-type

263

<a name="l00236"></a>00236 {

264

<a name="l00237"></a>00237 if (arg_gap) // second argument block is GAP-type

265

<a name="l00238"></a>00238 {

266

<a name="l00239"></a>00239 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

267

<a name="l00240"></a>00240 {

268

<a name="l00241"></a>00241 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

269

<a name="l00242"></a>00242

270

<a name="l00243"></a>00243 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

271

<a name="l00244"></a>00244 {

272

<a name="l00245"></a>00245 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

273

<a name="l00246"></a>00246 if (blk)

274

<a name="l00247"></a>00247 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gab87384cbf46a04d86c008ab2463d02cc" title="Compute bitcount of bit block AND masked by GAP block.">gap_bitset_and_count</a>(blk, g2);

275

<a name="l00248"></a>00248 break;

276

<a name="l00249"></a>00249 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

277

<a name="l00250"></a>00250 if (!blk)

278

<a name="l00251"></a>00251 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g2);

279

<a name="l00252"></a>00252 else

280

<a name="l00253"></a>00253 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#ga23733890861063a59f787e26763a734a" title="Compute bitcount of bit block OR masked by GAP block.">gap_bitset_or_count</a>(blk, g2);

281

<a name="l00254"></a>00254 break;

282

<a name="l00255"></a>00255 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

283

<a name="l00256"></a>00256 if (blk)

284

<a name="l00257"></a>00257 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#ga15a780da58d5aeb67ffc51c84fa6152e" title="Compute bitcount of bit block SUB masked by GAP block.">gap_bitset_sub_count</a>(blk, g2);

285

<a name="l00258"></a>00258 break;

286

<a name="l00259"></a>00259 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

287

<a name="l00260"></a>00260 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>; // recursive call to SUB_AB

288

<a name="l00261"></a>00261 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(arg_blk,

289

<a name="l00262"></a>00262 arg_gap,

290

<a name="l00263"></a>00263 blk,

291

<a name="l00264"></a>00264 gap,

292

<a name="l00265"></a>00265 temp_blk,

293

<a name="l00266"></a>00266 it, it+1);

294

<a name="l00267"></a>00267 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>; // restore status quo

295

<a name="l00268"></a>00268 break;

296

<a name="l00269"></a>00269 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

297

<a name="l00270"></a>00270 if (!blk)

298

<a name="l00271"></a>00271 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g2);

299

<a name="l00272"></a>00272 else

300

<a name="l00273"></a>00273 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#ga803fbc7c790f07b14175303e524bd2d8" title="Compute bitcount of bit block XOR masked by GAP block.">gap_bitset_xor_count</a>(blk, g2);

301

<a name="l00274"></a>00274 break;

302

<a name="l00275"></a>00275 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

303

<a name="l00276"></a>00276 if (blk)

304

<a name="l00277"></a>00277 {

305

<a name="l00278"></a>00278 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

306

<a name="l00279"></a>00279 <a class="code" href="a00115.html#gab30df14a61f036d690c091878feaff1c" title="Bitcount for bit string.">bit_block_calc_count</a>(blk,

307

<a name="l00280"></a>00280 blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

308

<a name="l00281"></a>00281 }

309

<a name="l00282"></a>00282 break;

310

<a name="l00283"></a>00283 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

311

<a name="l00284"></a>00284 if (g2)

312

<a name="l00285"></a>00285 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#ga570a6f573ffb9ac9e41a688d2bdc6004" title="Calculates number of bits ON in GAP buffer.">gap_bit_count</a>(g2);

313

<a name="l00286"></a>00286 break;

314

<a name="l00287"></a>00287 } // switch

315

<a name="l00288"></a>00288

316

<a name="l00289"></a>00289 } // for it

317

<a name="l00290"></a>00290

318

<a name="l00291"></a>00291 return;

319

<a name="l00292"></a>00292 }

320

<a name="l00293"></a>00293 }

321

<a name="l00294"></a>00294

322

<a name="l00295"></a>00295 // --------------------------------------------

323

<a name="l00296"></a>00296 //

324

<a name="l00297"></a>00297 // Here we combine two plain bitblocks

325

<a name="l00298"></a>00298

326

<a name="l00299"></a>00299 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk_end;

327

<a name="l00300"></a>00300 //const bm::word_t* arg_end;

328

<a name="l00301"></a>00301

329

<a name="l00302"></a>00302 blk_end = blk + (<a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

330

<a name="l00303"></a>00303 //arg_end = arg_blk + (bm::set_block_size);

331

<a name="l00304"></a>00304

332

<a name="l00305"></a>00305

333

<a name="l00306"></a>00306 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit; it < dmit_end; ++it)

334

<a name="l00307"></a>00307 {

335

<a name="l00308"></a>00308 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

336

<a name="l00309"></a>00309 <a class="code" href="a00110.html#ad93f96a77f223240b8c6b8f81c5db840">bit_operation_count_func_type</a> gfunc =

337

<a name="l00310"></a>00310 <a class="code" href="a00076.html#a4fc04066445af644759bf65ebf765760">operation_functions<true>::bit_operation_count</a>(dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>);

338

<a name="l00311"></a>00311 if (gfunc)

339

<a name="l00312"></a>00312 {

340

<a name="l00313"></a>00313 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += (*gfunc)(blk, blk_end, arg_blk);

341

<a name="l00314"></a>00314 }

342

<a name="l00315"></a>00315 else

343

<a name="l00316"></a>00316 {

344

<a name="l00317"></a>00317 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

345

<a name="l00318"></a>00318 {

346

<a name="l00319"></a>00319 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

347

<a name="l00320"></a>00320 if (blk)

348

<a name="l00321"></a>00321 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gab30df14a61f036d690c091878feaff1c" title="Bitcount for bit string.">bit_block_calc_count</a>(blk, blk_end);

349

<a name="l00322"></a>00322 break;

350

<a name="l00323"></a>00323 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

351

<a name="l00324"></a>00324 if (arg_blk)

352

<a name="l00325"></a>00325 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

353

<a name="l00326"></a>00326 <a class="code" href="a00115.html#gab30df14a61f036d690c091878feaff1c" title="Bitcount for bit string.">bit_block_calc_count</a>(arg_blk,

354

<a name="l00327"></a>00327 arg_blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

355

<a name="l00328"></a>00328 break;

356

<a name="l00329"></a>00329 default:

357

<a name="l00330"></a>00330 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

358

<a name="l00331"></a>00331 } // switch

359

<a name="l00332"></a>00332 }

360

<a name="l00333"></a>00333

361

<a name="l00334"></a>00334 } // for it

362

<a name="l00335"></a>00335 }

363

<a name="l00336"></a>00336

364

<a name="l00337"></a>00337 /*!

365

<a name="l00338"></a>00338 \brief Internal function computes different existense of distance metric.

366

<a name="l00339"></a>00339 \internal

367

<a name="l00340"></a>00340 \ingroup distance

368

<a name="l00341"></a>00341 */

369

<a name="l00342"></a>00342 inline

370

<a name="l00343"></a><a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc">00343</a> void <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

371

<a name="l00344"></a>00344 unsigned gap,

372

<a name="l00345"></a>00345 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

373

<a name="l00346"></a>00346 int arg_gap,

374

<a name="l00347"></a>00347 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk,

375

<a name="l00348"></a>00348 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit,

376

<a name="l00349"></a>00349 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit_end)

377

<a name="l00350"></a>00350

378

<a name="l00351"></a>00351 {

379

<a name="l00352"></a>00352 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* res=0;

380

<a name="l00353"></a>00353

381

<a name="l00354"></a>00354 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* g1 = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

382

<a name="l00355"></a>00355 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a>* g2 = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(arg_blk);

383

<a name="l00356"></a>00356

384

<a name="l00357"></a>00357 if (gap) // first block GAP-type

385

<a name="l00358"></a>00358 {

386

<a name="l00359"></a>00359 if (arg_gap) // both blocks GAP-type

387

<a name="l00360"></a>00360 {

388

<a name="l00361"></a>00361 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">gap_word_t</a> tmp_buf[<a class="code" href="a00110.html#aa5e01dfb650d168f9be0525e042af647">bm::gap_max_buff_len</a> * 3]; // temporary result

389

<a name="l00362"></a>00362

390

<a name="l00363"></a>00363 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

391

<a name="l00364"></a>00364 {

392

<a name="l00365"></a>00365 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

393

<a name="l00366"></a>00366 if (dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

394

<a name="l00367"></a>00367 {

395

<a name="l00368"></a>00368 continue;

396

<a name="l00369"></a>00369 }

397

<a name="l00370"></a>00370 res = 0;

398

<a name="l00371"></a>00371 unsigned dsize = 0;

399

<a name="l00372"></a>00372 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

400

<a name="l00373"></a>00373 {

401

<a name="l00374"></a>00374 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

402

<a name="l00375"></a>00375 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#gafb24a1e2588c5670df6facc537594d9d" title="GAP AND operation test.">gap_operation_any_and</a>(g1, g2);

403

<a name="l00376"></a>00376 break;

404

<a name="l00377"></a>00377 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

405

<a name="l00378"></a>00378 res = <a class="code" href="a00114.html#gacda280af8910ae5fde37731a3a7a1226" title="GAP OR operation.">gap_operation_or</a>(g1, g2, tmp_buf, dsize);

406

<a name="l00379"></a>00379 break;

407

<a name="l00380"></a>00380 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

408

<a name="l00381"></a>00381 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#gae0b1d4aca0ddfa58d83e4b089a4f35d9" title="GAP SUB operation test.">gap_operation_any_sub</a>(g1, g2);

409

<a name="l00382"></a>00382 break;

410

<a name="l00383"></a>00383 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

411

<a name="l00384"></a>00384 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#gae0b1d4aca0ddfa58d83e4b089a4f35d9" title="GAP SUB operation test.">gap_operation_any_sub</a>(g2, g1);

412

<a name="l00385"></a>00385 break;

413

<a name="l00386"></a>00386 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

414

<a name="l00387"></a>00387 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00114.html#gab46833bf0d7813f868a1608f70db12de" title="GAP XOR operation test.">gap_operation_any_xor</a>(g1, g2);

415

<a name="l00388"></a>00388 break;

416

<a name="l00389"></a>00389 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

417

<a name="l00390"></a>00390 res = g1;

418

<a name="l00391"></a>00391 break;

419

<a name="l00392"></a>00392 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

420

<a name="l00393"></a>00393 res = g2;

421

<a name="l00394"></a>00394 break;

422

<a name="l00395"></a>00395 } // switch

423

<a name="l00396"></a>00396 if (res)

424

<a name="l00397"></a>00397 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(res, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

425

<a name="l00398"></a>00398

426

<a name="l00399"></a>00399 } // for it

427

<a name="l00400"></a>00400

428

<a name="l00401"></a>00401 return;

429

<a name="l00402"></a>00402

430

<a name="l00403"></a>00403 }

431

<a name="l00404"></a>00404 else // first block - GAP, argument - BITSET

432

<a name="l00405"></a>00405 {

433

<a name="l00406"></a>00406 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

434

<a name="l00407"></a>00407 {

435

<a name="l00408"></a>00408 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

436

<a name="l00409"></a>00409 if (dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

437

<a name="l00410"></a>00410 {

438

<a name="l00411"></a>00411 continue;

439

<a name="l00412"></a>00412 }

440

<a name="l00413"></a>00413

441

<a name="l00414"></a>00414 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

442

<a name="l00415"></a>00415 {

443

<a name="l00416"></a>00416 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

444

<a name="l00417"></a>00417 if (arg_blk)

445

<a name="l00418"></a>00418 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad6e40898b8836ae1923b06a3d028fcaa" title="Bitcount test of bit block AND masked by GAP block.">gap_bitset_and_any</a>(arg_blk, g1);

446

<a name="l00419"></a>00419 break;

447

<a name="l00420"></a>00420 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

448

<a name="l00421"></a>00421 if (!arg_blk)

449

<a name="l00422"></a>00422 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g1, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

450

<a name="l00423"></a>00423 else

451

<a name="l00424"></a>00424 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad15f1b92c70752cd3b97fa9e0c585f00" title="Compute bitcount test of bit block OR masked by GAP block.">gap_bitset_or_any</a>(arg_blk, g1);

452

<a name="l00425"></a>00425 break;

453

<a name="l00426"></a>00426 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

454

<a name="l00427"></a>00427 <a class="code" href="a00114.html#ga4862f4dcdcb7c0575e2e2db9e5f2a849" title="GAP block to bitblock conversion.">gap_convert_to_bitset</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*) temp_blk, g1);

455

<a name="l00428"></a>00428 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

456

<a name="l00429"></a>00429 <a class="code" href="a00115.html#ga847d5a84673b284be984f0db583e2723" title="Performs bitblock test of SUB operation.">bit_operation_sub_any</a>((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk,

457

<a name="l00430"></a>00430 ((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*)temp_blk) + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>,

458

<a name="l00431"></a>00431 arg_blk);

459

<a name="l00432"></a>00432

460

<a name="l00433"></a>00433 break;

461

<a name="l00434"></a>00434 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

462

<a name="l00435"></a>00435 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>; // recursive call to SUB_AB

463

<a name="l00436"></a>00436 <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(arg_blk,

464

<a name="l00437"></a>00437 arg_gap,

465

<a name="l00438"></a>00438 blk,

466

<a name="l00439"></a>00439 gap,

467

<a name="l00440"></a>00440 temp_blk,

468

<a name="l00441"></a>00441 it, it+1);

469

<a name="l00442"></a>00442 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>; // restore status quo

470

<a name="l00443"></a>00443 break;

471

<a name="l00444"></a>00444 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

472

<a name="l00445"></a>00445 if (!arg_blk)

473

<a name="l00446"></a>00446 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g1, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

474

<a name="l00447"></a>00447 else

475

<a name="l00448"></a>00448 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad0f7ee00f84ea357d55e6a2f507c8918" title="Compute bitcount test of bit block XOR masked by GAP block.">gap_bitset_xor_any</a>(arg_blk, g1);

476

<a name="l00449"></a>00449 break;

477

<a name="l00450"></a>00450 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

478

<a name="l00451"></a>00451 if (g1)

479

<a name="l00452"></a>00452 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g1, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

480

<a name="l00453"></a>00453 break;

481

<a name="l00454"></a>00454 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

482

<a name="l00455"></a>00455 if (arg_blk)

483

<a name="l00456"></a>00456 {

484

<a name="l00457"></a>00457 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

485

<a name="l00458"></a>00458 !<a class="code" href="a00115.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>((<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk,

486

<a name="l00459"></a>00459 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)(arg_blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>));

487

<a name="l00460"></a>00460 }

488

<a name="l00461"></a>00461 break;

489

<a name="l00462"></a>00462 } // switch

490

<a name="l00463"></a>00463

491

<a name="l00464"></a>00464 } // for it

492

<a name="l00465"></a>00465

493

<a name="l00466"></a>00466 return;

494

<a name="l00467"></a>00467

495

<a name="l00468"></a>00468 }

496

<a name="l00469"></a>00469 }

497

<a name="l00470"></a>00470 else // first block is BITSET-type

498

<a name="l00471"></a>00471 {

499

<a name="l00472"></a>00472 if (arg_gap) // second argument block is GAP-type

500

<a name="l00473"></a>00473 {

501

<a name="l00474"></a>00474 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit;it < dmit_end; ++it)

502

<a name="l00475"></a>00475 {

503

<a name="l00476"></a>00476 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

504

<a name="l00477"></a>00477 if (dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

505

<a name="l00478"></a>00478 {

506

<a name="l00479"></a>00479 continue;

507

<a name="l00480"></a>00480 }

508

<a name="l00481"></a>00481

509

<a name="l00482"></a>00482 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

510

<a name="l00483"></a>00483 {

511

<a name="l00484"></a>00484 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

512

<a name="l00485"></a>00485 if (blk)

513

<a name="l00486"></a>00486 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad6e40898b8836ae1923b06a3d028fcaa" title="Bitcount test of bit block AND masked by GAP block.">gap_bitset_and_any</a>(blk, g2);

514

<a name="l00487"></a>00487 break;

515

<a name="l00488"></a>00488 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

516

<a name="l00489"></a>00489 if (!blk)

517

<a name="l00490"></a>00490 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g2, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

518

<a name="l00491"></a>00491 else

519

<a name="l00492"></a>00492 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad15f1b92c70752cd3b97fa9e0c585f00" title="Compute bitcount test of bit block OR masked by GAP block.">gap_bitset_or_any</a>(blk, g2);

520

<a name="l00493"></a>00493 break;

521

<a name="l00494"></a>00494 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

522

<a name="l00495"></a>00495 if (blk)

523

<a name="l00496"></a>00496 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gaab7c711122e8f189555dffd83a21111c" title="Compute bitcount test of bit block SUB masked by GAP block.">gap_bitset_sub_any</a>(blk, g2);

524

<a name="l00497"></a>00497 break;

525

<a name="l00498"></a>00498 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

526

<a name="l00499"></a>00499 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>; // recursive call to SUB_AB

527

<a name="l00500"></a>00500 <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(arg_blk,

528

<a name="l00501"></a>00501 arg_gap,

529

<a name="l00502"></a>00502 blk,

530

<a name="l00503"></a>00503 gap,

531

<a name="l00504"></a>00504 temp_blk,

532

<a name="l00505"></a>00505 it, it+1);

533

<a name="l00506"></a>00506 dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a> = <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>; // restore status quo

534

<a name="l00507"></a>00507 break;

535

<a name="l00508"></a>00508 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

536

<a name="l00509"></a>00509 if (!blk)

537

<a name="l00510"></a>00510 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g2, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

538

<a name="l00511"></a>00511 else

539

<a name="l00512"></a>00512 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += <a class="code" href="a00115.html#gad0f7ee00f84ea357d55e6a2f507c8918" title="Compute bitcount test of bit block XOR masked by GAP block.">gap_bitset_xor_any</a>(blk, g2);

540

<a name="l00513"></a>00513 break;

541

<a name="l00514"></a>00514 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

542

<a name="l00515"></a>00515 if (blk)

543

<a name="l00516"></a>00516 {

544

<a name="l00517"></a>00517 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>+=

545

<a name="l00518"></a>00518 !<a class="code" href="a00115.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>((<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk,

546

<a name="l00519"></a>00519 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

547

<a name="l00520"></a>00520 }

548

<a name="l00521"></a>00521 break;

549

<a name="l00522"></a>00522 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

550

<a name="l00523"></a>00523 if (g2)

551

<a name="l00524"></a>00524 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00114.html#ga690ff7c8b16e1821a77663b7194267e7" title="Temporary inverts all bits in the GAP buffer.">gap_is_all_zero</a>(g2, <a class="code" href="a00110.html#ad0b8714080144ac70197840ff96752b7">bm::gap_max_bits</a>);

552

<a name="l00525"></a>00525 break;

553

<a name="l00526"></a>00526 } // switch

554

<a name="l00527"></a>00527

555

<a name="l00528"></a>00528 } // for it

556

<a name="l00529"></a>00529

557

<a name="l00530"></a>00530 return;

558

<a name="l00531"></a>00531 }

559

<a name="l00532"></a>00532 }

560

<a name="l00533"></a>00533

561

<a name="l00534"></a>00534 // --------------------------------------------

562

<a name="l00535"></a>00535 //

563

<a name="l00536"></a>00536 // Here we combine two plain bitblocks

564

<a name="l00537"></a>00537

565

<a name="l00538"></a>00538 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk_end;

566

<a name="l00539"></a>00539 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_end;

567

<a name="l00540"></a>00540

568

<a name="l00541"></a>00541 blk_end = blk + (<a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

569

<a name="l00542"></a>00542 arg_end = arg_blk + (<a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>);

570

<a name="l00543"></a>00543

571

<a name="l00544"></a>00544 for (<a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit; it < dmit_end; ++it)

572

<a name="l00545"></a>00545 {

573

<a name="l00546"></a>00546 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>& dmd = *it;

574

<a name="l00547"></a>00547 if (dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

575

<a name="l00548"></a>00548 {

576

<a name="l00549"></a>00549 continue;

577

<a name="l00550"></a>00550 }

578

<a name="l00551"></a>00551

579

<a name="l00552"></a>00552 switch (dmd.<a class="code" href="a00060.html#a3ece2ccdb7a6616f06a5a15679ccabb1">metric</a>)

580

<a name="l00553"></a>00553 {

581

<a name="l00554"></a>00554 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>:

582

<a name="l00555"></a>00555 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

583

<a name="l00556"></a>00556 <a class="code" href="a00115.html#ga0e7995f7d6c791f6ff27a8dd21d324e5" title="Performs bitblock AND operation test.">bit_operation_and_any</a>(blk, blk_end, arg_blk);

584

<a name="l00557"></a>00557 break;

585

<a name="l00558"></a>00558 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>:

586

<a name="l00559"></a>00559 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

587

<a name="l00560"></a>00560 <a class="code" href="a00115.html#ga6d26742bdc373074474a6932eab4f388" title="Performs bitblock OR operation test.">bit_operation_or_any</a>(blk, blk_end, arg_blk);

588

<a name="l00561"></a>00561 break;

589

<a name="l00562"></a>00562 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>:

590

<a name="l00563"></a>00563 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

591

<a name="l00564"></a>00564 <a class="code" href="a00115.html#ga847d5a84673b284be984f0db583e2723" title="Performs bitblock test of SUB operation.">bit_operation_sub_any</a>(blk, blk_end, arg_blk);

592

<a name="l00565"></a>00565 break;

593

<a name="l00566"></a>00566 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>:

594

<a name="l00567"></a>00567 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

595

<a name="l00568"></a>00568 <a class="code" href="a00115.html#ga847d5a84673b284be984f0db583e2723" title="Performs bitblock test of SUB operation.">bit_operation_sub_any</a>(arg_blk, arg_end, blk);

596

<a name="l00569"></a>00569 break;

597

<a name="l00570"></a>00570 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>:

598

<a name="l00571"></a>00571 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> +=

599

<a name="l00572"></a>00572 <a class="code" href="a00115.html#gaa86561b6d11c3f01dd772563c692f732" title="Performs bitblock XOR operation test.">bit_operation_xor_any</a>(blk, blk_end, arg_blk);

600

<a name="l00573"></a>00573 break;

601

<a name="l00574"></a>00574 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abaac7947d53eb3acf81251ee4130e6a4a2" title="A.count().">bm::COUNT_A</a>:

602

<a name="l00575"></a>00575 if (blk)

603

<a name="l00576"></a>00576 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00115.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>((<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk,

604

<a name="l00577"></a>00577 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)blk_end);

605

<a name="l00578"></a>00578 break;

606

<a name="l00579"></a>00579 case <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abac6dbadf2ab9405daa47dc0f10d082516" title="B.count().">bm::COUNT_B</a>:

607

<a name="l00580"></a>00580 if (arg_blk)

608

<a name="l00581"></a>00581 dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a> += !<a class="code" href="a00115.html#gac6cfb9f92e4df6bb4c76f6efb2382860" title="Returns &quot;true&quot; if all bits in the block are 0.">bit_is_all_zero</a>((<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_blk,

609

<a name="l00582"></a>00582 (<a class="code" href="a00110.html#a7176bf7817550ca24cb6612bd8d7957d">bm::wordop_t</a>*)arg_end);

610

<a name="l00583"></a>00583 break;

611

<a name="l00584"></a>00584 } // switch

612

<a name="l00585"></a>00585

613

<a name="l00586"></a>00586 } // for it

614

<a name="l00587"></a>00587 }

615

<a name="l00588"></a>00588

616

<a name="l00589"></a>00589

617

<a name="l00590"></a>00590

618

<a name="l00591"></a>00591 /*!

619

<a name="l00592"></a>00592 Convenience internal function to compute combine count for one metric

620

<a name="l00593"></a>00593 \internal

621

<a name="l00594"></a>00594 \ingroup distance

622

<a name="l00595"></a>00595 */

623

<a name="l00596"></a>00596 inline

624

<a name="l00597"></a><a class="code" href="a00110.html#a2f81b8ce3d389973b4f867b0fcc98e7a">00597</a> unsigned <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

625

<a name="l00598"></a>00598 unsigned gap,

626

<a name="l00599"></a>00599 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

627

<a name="l00600"></a>00600 int arg_gap,

628

<a name="l00601"></a>00601 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk,

629

<a name="l00602"></a>00602 <a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a> metric)

630

<a name="l00603"></a>00603 {

631

<a name="l00604"></a>00604 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(metric);

632

<a name="l00605"></a>00605 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(blk, gap,

633

<a name="l00606"></a>00606 arg_blk, arg_gap,

634

<a name="l00607"></a>00607 temp_blk,

635

<a name="l00608"></a>00608 &dmd, &dmd+1);

636

<a name="l00609"></a>00609 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

637

<a name="l00610"></a>00610 }

638

<a name="l00611"></a>00611

639

<a name="l00612"></a>00612

640

<a name="l00613"></a>00613 /*!

641

<a name="l00614"></a>00614 Convenience internal function to compute combine any for one metric

642

<a name="l00615"></a>00615 \internal

643

<a name="l00616"></a>00616 \ingroup distance

644

<a name="l00617"></a>00617 */

645

<a name="l00618"></a>00618 inline

646

<a name="l00619"></a><a class="code" href="a00110.html#a093f2dadce40f42a184928c9d1456592">00619</a> unsigned <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk,

647

<a name="l00620"></a>00620 unsigned gap,

648

<a name="l00621"></a>00621 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk,

649

<a name="l00622"></a>00622 int arg_gap,

650

<a name="l00623"></a>00623 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk,

651

<a name="l00624"></a>00624 <a class="code" href="a00120.html#gac38d64c8b27b652413a664cddd4d40ab" title="Distance metrics codes defined for vectors A and B.">distance_metric</a> metric)

652

<a name="l00625"></a>00625 {

653

<a name="l00626"></a>00626 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(metric);

654

<a name="l00627"></a>00627 <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(blk, gap,

655

<a name="l00628"></a>00628 arg_blk, arg_gap,

656

<a name="l00629"></a>00629 temp_blk,

657

<a name="l00630"></a>00630 &dmd, &dmd+1);

658

<a name="l00631"></a>00631 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

659

<a name="l00632"></a>00632 }

660

<a name="l00633"></a>00633

661

<a name="l00634"></a>00634 /*!

662

<a name="l00635"></a>00635 \brief Staging function for distance operation

663

<a name="l00636"></a>00636

664

<a name="l00637"></a>00637 \return temp block allocated (or NULL)

665

<a name="l00638"></a>00638

666

<a name="l00639"></a>00639 \internal

667

<a name="l00640"></a>00640 */

668

<a name="l00641"></a>00641 template<class BV>

669

<a name="l00642"></a><a class="code" href="a00110.html#ad47cf2dce876dcbc25aef4c7a222c66f">00642</a> <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* <a class="code" href="a00110.html#ad47cf2dce876dcbc25aef4c7a222c66f" title="Staging function for distance operation.">distance_stage</a>(const BV& bv1,

670

<a name="l00643"></a>00643 const <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit,

671

<a name="l00644"></a>00644 const <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit_end,

672

<a name="l00645"></a>00645 bool* is_all_and)

673

<a name="l00646"></a>00646 {

674

<a name="l00647"></a>00647 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk = 0;

675

<a name="l00648"></a>00648 for (const <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it = dmit; it < dmit_end; ++it)

676

<a name="l00649"></a>00649 {

677

<a name="l00650"></a>00650 // allocate temp block when necessary

678

<a name="l00651"></a>00651 if (temp_blk == 0)

679

<a name="l00652"></a>00652 {

680

<a name="l00653"></a>00653 if (it->metric == <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a> ||

681

<a name="l00654"></a>00654 it->metric == <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abafa036fb9d54bc659ed3c9e4185ccf400" title="(B - A).count()">bm::COUNT_SUB_BA</a>)

682

<a name="l00655"></a>00655 {

683

<a name="l00656"></a>00656 temp_blk = bv1.allocate_tempblock();

684

<a name="l00657"></a>00657 }

685

<a name="l00658"></a>00658 }

686

<a name="l00659"></a>00659 if (it->metric != <a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>)

687

<a name="l00660"></a>00660 {

688

<a name="l00661"></a>00661 *is_all_and = false;

689

<a name="l00662"></a>00662 }

690

<a name="l00663"></a>00663 } // for

691

<a name="l00664"></a>00664 return temp_blk;

692

<a name="l00665"></a>00665 }

693

<a name="l00666"></a>00666

694

<a name="l00667"></a>00667 /*!

695

<a name="l00668"></a>00668 \brief Distance computing template function.

696

<a name="l00669"></a>00669

697

<a name="l00670"></a>00670 Function receives two bitvectors and an array of distance metrics

698

<a name="l00671"></a>00671 (metrics pipeline). Function computes all metrics saves result into

699

<a name="l00672"></a>00672 corresponding pipeline results (distance_metric_descriptor::result)

700

<a name="l00673"></a>00673 An important detail is that function reuses metric descriptors,

701

<a name="l00674"></a>00674 incrementing received values. It allows you to accumulate results

702

<a name="l00675"></a>00675 from different calls in the pipeline.

703

<a name="l00676"></a>00676

704

<a name="l00677"></a>00677 \param bv1 - argument bitvector 1 (A)

705

<a name="l00678"></a>00678 \param bv2 - argument bitvector 2 (B)

706

<a name="l00679"></a>00679 \param dmit - pointer to first element of metric descriptors array

707

<a name="l00680"></a>00680 Input-Output parameter, receives metric code as input,

708

<a name="l00681"></a>00681 computation is added to "result" field

709

<a name="l00682"></a>00682 \param dmit_end - pointer to (last+1) element of metric descriptors array

710

<a name="l00683"></a>00683 \ingroup distance

711

<a name="l00684"></a>00684

712

<a name="l00685"></a>00685 */

713

<a name="l00686"></a>00686

714

<a name="l00687"></a>00687 template<class BV>

715

<a name="l00688"></a><a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b">00688</a> void <a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b" title="Distance computing template function.">distance_operation</a>(const BV& bv1,

716

<a name="l00689"></a>00689 const BV& bv2,

717

<a name="l00690"></a>00690 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit,

718

<a name="l00691"></a>00691 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit_end)

719

<a name="l00692"></a>00692 {

720

<a name="l00693"></a>00693 const typename BV::blocks_manager_type& bman1 = bv1.get_blocks_manager();

721

<a name="l00694"></a>00694 const typename BV::blocks_manager_type& bman2 = bv2.get_blocks_manager();

722

<a name="l00695"></a>00695

723

<a name="l00696"></a>00696 bool is_all_and = true; // flag is distance operation is just COUNT_AND

724

<a name="l00697"></a>00697 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk = <a class="code" href="a00110.html#ad47cf2dce876dcbc25aef4c7a222c66f" title="Staging function for distance operation.">distance_stage</a>(bv1, dmit, dmit_end, &is_all_and);

725

<a name="l00698"></a>00698

726

<a name="l00699"></a>00699 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = bman1.get_rootblock();

727

<a name="l00700"></a>00700 unsigned block_idx = 0;

728

<a name="l00701"></a>00701 unsigned i, j;

729

<a name="l00702"></a>00702

730

<a name="l00703"></a>00703 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk;

731

<a name="l00704"></a>00704 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk;

732

<a name="l00705"></a>00705 bool blk_gap;

733

<a name="l00706"></a>00706 bool arg_gap;

734

<a name="l00707"></a>00707

735

<a name="l00708"></a>00708 <a class="code" href="a00089.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

736

<a name="l00709"></a>00709

737

<a name="l00710"></a>00710 unsigned effective_top_block_size = bman1.effective_top_block_size();

738

<a name="l00711"></a>00711 unsigned ebs2 = bman2.effective_top_block_size();

739

<a name="l00712"></a>00712 if (ebs2 > effective_top_block_size)

740

<a name="l00713"></a>00713 effective_top_block_size = ebs2;

741

<a name="l00714"></a>00714

742

<a name="l00715"></a>00715 for (i = 0; i < effective_top_block_size; ++i)

743

<a name="l00716"></a>00716 {

744

<a name="l00717"></a>00717 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = blk_root[i];

745

<a name="l00718"></a>00718

746

<a name="l00719"></a>00719 if (blk_blk == 0) // not allocated

747

<a name="l00720"></a>00720 {

748

<a name="l00721"></a>00721 // AND operation requested - we can skip this portion here

749

<a name="l00722"></a>00722 if (is_all_and)

750

<a name="l00723"></a>00723 {

751

<a name="l00724"></a>00724 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

752

<a name="l00725"></a>00725 continue;

753

<a name="l00726"></a>00726 }

754

<a name="l00727"></a>00727 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* bvbb = bman2.get_topblock(i);

755

<a name="l00728"></a>00728 if (bvbb == 0)

756

<a name="l00729"></a>00729 {

757

<a name="l00730"></a>00730 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

758

<a name="l00731"></a>00731 continue;

759

<a name="l00732"></a>00732 }

760

<a name="l00733"></a>00733

761

<a name="l00734"></a>00734 blk = 0;

762

<a name="l00735"></a>00735 blk_gap = false;

763

<a name="l00736"></a>00736

764

<a name="l00737"></a>00737 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++block_idx)

765

<a name="l00738"></a>00738 {

766

<a name="l00739"></a>00739 arg_blk = bman2.get_block(i, j);

767

<a name="l00740"></a>00740 arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman2, arg_blk, block_idx);

768

<a name="l00741"></a>00741

769

<a name="l00742"></a>00742 if (!arg_blk)

770

<a name="l00743"></a>00743 continue;

771

<a name="l00744"></a>00744 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(blk, blk_gap,

772

<a name="l00745"></a>00745 arg_blk, arg_gap,

773

<a name="l00746"></a>00746 temp_blk,

774

<a name="l00747"></a>00747 dmit, dmit_end);

775

<a name="l00748"></a>00748 } // for j

776

<a name="l00749"></a>00749 continue;

777

<a name="l00750"></a>00750 }

778

<a name="l00751"></a>00751

779

<a name="l00752"></a>00752 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

780

<a name="l00753"></a>00753 {

781

<a name="l00754"></a>00754 blk = blk_blk[j];

782

<a name="l00755"></a>00755 if (blk == 0 && is_all_and)

783

<a name="l00756"></a>00756 continue;

784

<a name="l00757"></a>00757

785

<a name="l00758"></a>00758 arg_blk = bman2.get_block(i, j);

786

<a name="l00759"></a>00759

787

<a name="l00760"></a>00760 if (blk == 0 && arg_blk == 0)

788

<a name="l00761"></a>00761 continue;

789

<a name="l00762"></a>00762

790

<a name="l00763"></a>00763 arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman2, arg_blk, block_idx);

791

<a name="l00764"></a>00764 blk_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman1, blk, block_idx);

792

<a name="l00765"></a>00765

793

<a name="l00766"></a>00766 <a class="code" href="a00110.html#abecd5b24d5e394fd46a9db514cfa659a" title="Internal function computes different distance metrics.">combine_count_operation_with_block</a>(blk, blk_gap,

794

<a name="l00767"></a>00767 arg_blk, arg_gap,

795

<a name="l00768"></a>00768 temp_blk,

796

<a name="l00769"></a>00769 dmit, dmit_end);

797

<a name="l00770"></a>00770

798

<a name="l00771"></a>00771

799

<a name="l00772"></a>00772 } // for j

800

<a name="l00773"></a>00773

801

<a name="l00774"></a>00774 } // for i

802

<a name="l00775"></a>00775

803

<a name="l00776"></a>00776 if (temp_blk)

804

<a name="l00777"></a>00777 {

805

<a name="l00778"></a>00778 bv1.free_tempblock(temp_blk);

806

<a name="l00779"></a>00779 }

807

<a name="l00780"></a>00780

808

<a name="l00781"></a>00781 }

809

<a name="l00782"></a>00782

810

<a name="l00783"></a>00783

811

<a name="l00784"></a>00784

812

<a name="l00785"></a>00785 /*!

813

<a name="l00786"></a>00786 \brief Distance screening template function.

814

<a name="l00787"></a>00787

815

<a name="l00788"></a>00788 Function receives two bitvectors and an array of distance metrics

816

<a name="l00789"></a>00789 (metrics pipeline). Function computes possybility of a metric(any bit)

817

<a name="l00790"></a>00790 saves result into corresponding pipeline results

818

<a name="l00791"></a>00791 (distance_metric_descriptor::result)

819

<a name="l00792"></a>00792 An important detail is that function reuses metric descriptors,

820

<a name="l00793"></a>00793 incrementing received values. It allows you to accumulate results

821

<a name="l00794"></a>00794 from different calls in the pipeline.

822

<a name="l00795"></a>00795

823

<a name="l00796"></a>00796 \param bv1 - argument bitvector 1 (A)

824

<a name="l00797"></a>00797 \param bv2 - argument bitvector 2 (B)

825

<a name="l00798"></a>00798 \param dmit - pointer to first element of metric descriptors array

826

<a name="l00799"></a>00799 Input-Output parameter, receives metric code as input,

827

<a name="l00800"></a>00800 computation is added to "result" field

828

<a name="l00801"></a>00801 \param dmit_end - pointer to (last+1) element of metric descriptors array

829

<a name="l00802"></a>00802 \ingroup distance

830

<a name="l00803"></a>00803

831

<a name="l00804"></a>00804 */

832

<a name="l00805"></a>00805

833

<a name="l00806"></a>00806 template<class BV>

834

<a name="l00807"></a><a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e">00807</a> void <a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e" title="Distance screening template function.">distance_operation_any</a>(const BV& bv1,

835

<a name="l00808"></a>00808 const BV& bv2,

836

<a name="l00809"></a>00809 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit,

837

<a name="l00810"></a>00810 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* dmit_end)

838

<a name="l00811"></a>00811 {

839

<a name="l00812"></a>00812 const typename BV::blocks_manager_type& bman1 = bv1.get_blocks_manager();

840

<a name="l00813"></a>00813 const typename BV::blocks_manager_type& bman2 = bv2.get_blocks_manager();

841

<a name="l00814"></a>00814

842

<a name="l00815"></a>00815 bool is_all_and = true; // flag is distance operation is just COUNT_AND

843

<a name="l00816"></a>00816 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* temp_blk = <a class="code" href="a00110.html#ad47cf2dce876dcbc25aef4c7a222c66f" title="Staging function for distance operation.">distance_stage</a>(bv1, dmit, dmit_end, &is_all_and);

844

<a name="l00817"></a>00817

845

<a name="l00818"></a>00818 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = bman1.get_rootblock();

846

<a name="l00819"></a>00819 unsigned block_idx = 0;

847

<a name="l00820"></a>00820 unsigned i, j;

848

<a name="l00821"></a>00821

849

<a name="l00822"></a>00822 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk;

850

<a name="l00823"></a>00823 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* arg_blk;

851

<a name="l00824"></a>00824 bool blk_gap;

852

<a name="l00825"></a>00825 bool arg_gap;

853

<a name="l00826"></a>00826

854

<a name="l00827"></a>00827 <a class="code" href="a00089.html#a7e6f87ba3230dece2125af5c32e84b05">BM_SET_MMX_GUARD</a>

855

<a name="l00828"></a>00828

856

<a name="l00829"></a>00829 unsigned effective_top_block_size = bman1.effective_top_block_size();

857

<a name="l00830"></a>00830 unsigned ebs2 = bman2.effective_top_block_size();

858

<a name="l00831"></a>00831 if (ebs2 > effective_top_block_size)

859

<a name="l00832"></a>00832 effective_top_block_size = ebs2;

860

<a name="l00833"></a>00833

861

<a name="l00834"></a>00834 for (i = 0; i < effective_top_block_size; ++i)

862

<a name="l00835"></a>00835 {

863

<a name="l00836"></a>00836 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>** blk_blk = blk_root[i];

864

<a name="l00837"></a>00837

865

<a name="l00838"></a>00838 if (blk_blk == 0) // not allocated

866

<a name="l00839"></a>00839 {

867

<a name="l00840"></a>00840 // AND operation requested - we can skip this portion here

868

<a name="l00841"></a>00841 if (is_all_and)

869

<a name="l00842"></a>00842 {

870

<a name="l00843"></a>00843 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

871

<a name="l00844"></a>00844 continue;

872

<a name="l00845"></a>00845 }

873

<a name="l00846"></a>00846

874

<a name="l00847"></a>00847 const <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* const* bvbb = bman2.get_topblock(i);

875

<a name="l00848"></a>00848 if (bvbb == 0)

876

<a name="l00849"></a>00849 {

877

<a name="l00850"></a>00850 block_idx += <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>;

878

<a name="l00851"></a>00851 continue;

879

<a name="l00852"></a>00852 }

880

<a name="l00853"></a>00853

881

<a name="l00854"></a>00854 blk = 0;

882

<a name="l00855"></a>00855 blk_gap = false;

883

<a name="l00856"></a>00856

884

<a name="l00857"></a>00857 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j,++block_idx)

885

<a name="l00858"></a>00858 {

886

<a name="l00859"></a>00859 arg_blk = bman2.get_block(i, j);

887

<a name="l00860"></a>00860 arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman2, arg_blk, block_idx);

888

<a name="l00861"></a>00861

889

<a name="l00862"></a>00862 if (!arg_blk)

890

<a name="l00863"></a>00863 continue;

891

<a name="l00864"></a>00864 <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(blk, blk_gap,

892

<a name="l00865"></a>00865 arg_blk, arg_gap,

893

<a name="l00866"></a>00866 temp_blk,

894

<a name="l00867"></a>00867 dmit, dmit_end);

895

<a name="l00868"></a>00868

896

<a name="l00869"></a>00869 // check if all distance requests alredy resolved

897

<a name="l00870"></a>00870 bool all_resolved = false;

898

<a name="l00871"></a>00871 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it=dmit;

899

<a name="l00872"></a>00872 do

900

<a name="l00873"></a>00873 {

901

<a name="l00874"></a>00874 if (!it-><a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

902

<a name="l00875"></a>00875 {

903

<a name="l00876"></a>00876 all_resolved = false;

904

<a name="l00877"></a>00877 break;

905

<a name="l00878"></a>00878 }

906

<a name="l00879"></a>00879 ++it;

907

<a name="l00880"></a>00880 } while (it < dmit_end);

908

<a name="l00881"></a>00881 if (all_resolved)

909

<a name="l00882"></a>00882 goto return_proc;

910

<a name="l00883"></a>00883 } // for j

911

<a name="l00884"></a>00884

912

<a name="l00885"></a>00885 continue;

913

<a name="l00886"></a>00886 }

914

<a name="l00887"></a>00887

915

<a name="l00888"></a>00888 for (j = 0; j < <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>; ++j, ++block_idx)

916

<a name="l00889"></a>00889 {

917

<a name="l00890"></a>00890 blk = blk_blk[j];

918

<a name="l00891"></a>00891 if (blk == 0 && is_all_and)

919

<a name="l00892"></a>00892 continue;

920

<a name="l00893"></a>00893

921

<a name="l00894"></a>00894 arg_blk = bman2.get_block(i, j);

922

<a name="l00895"></a>00895

923

<a name="l00896"></a>00896 if (blk == 0 && arg_blk == 0)

924

<a name="l00897"></a>00897 continue;

925

<a name="l00898"></a>00898

926

<a name="l00899"></a>00899 arg_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman2, arg_blk, block_idx);

927

<a name="l00900"></a>00900 blk_gap = <a class="code" href="a00089.html#a862d6f92b4de3ddb94fd367a800512eb">BM_IS_GAP</a>(bman1, blk, block_idx);

928

<a name="l00901"></a>00901

929

<a name="l00902"></a>00902 <a class="code" href="a00110.html#a24069ced9ea689034ff51246ae707ecc" title="Internal function computes different existense of distance metric.">combine_any_operation_with_block</a>(blk, blk_gap,

930

<a name="l00903"></a>00903 arg_blk, arg_gap,

931

<a name="l00904"></a>00904 temp_blk,

932

<a name="l00905"></a>00905 dmit, dmit_end);

933

<a name="l00906"></a>00906

934

<a name="l00907"></a>00907 // check if all distance requests alredy resolved

935

<a name="l00908"></a>00908 bool all_resolved = false;

936

<a name="l00909"></a>00909 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a>* it=dmit;

937

<a name="l00910"></a>00910 do

938

<a name="l00911"></a>00911 {

939

<a name="l00912"></a>00912 if (!it-><a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>)

940

<a name="l00913"></a>00913 {

941

<a name="l00914"></a>00914 all_resolved = false;

942

<a name="l00915"></a>00915 break;

943

<a name="l00916"></a>00916 }

944

<a name="l00917"></a>00917 ++it;

945

<a name="l00918"></a>00918 } while (it < dmit_end);

946

<a name="l00919"></a>00919 if (all_resolved)

947

<a name="l00920"></a>00920 goto return_proc;

948

<a name="l00921"></a>00921

949

<a name="l00922"></a>00922 } // for j

950

<a name="l00923"></a>00923

951

<a name="l00924"></a>00924 } // for i

952

<a name="l00925"></a>00925 return_proc:

953

<a name="l00926"></a>00926 if (temp_blk)

954

<a name="l00927"></a>00927 {

955

<a name="l00928"></a>00928 bv1.free_tempblock(temp_blk);

956

<a name="l00929"></a>00929 }

957

<a name="l00930"></a>00930

958

<a name="l00931"></a>00931 }

959

<a name="l00932"></a>00932

960

<a name="l00933"></a>00933

961

<a name="l00934"></a>00934

962

<a name="l00935"></a>00935 /*!

963

<a name="l00936"></a>00936 \brief Computes bitcount of AND operation of two bitsets

964

<a name="l00937"></a>00937 \param bv1 - Argument bit-vector.

965

<a name="l00938"></a>00938 \param bv2 - Argument bit-vector.

966

<a name="l00939"></a>00939 \return bitcount of the result

967

<a name="l00940"></a>00940 \ingroup distance

968

<a name="l00941"></a>00941 */

969

<a name="l00942"></a>00942 template<class BV>

970

<a name="l00943"></a><a class="code" href="a00120.html#gae451cb4b87e8c0859b0614d2ffb99737">00943</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#gae451cb4b87e8c0859b0614d2ffb99737" title="Computes bitcount of AND operation of two bitsets.">count_and</a>(const BV& bv1, const BV& bv2)

971

<a name="l00944"></a>00944 {

972

<a name="l00945"></a>00945 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>);

973

<a name="l00946"></a>00946

974

<a name="l00947"></a>00947 <a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b" title="Distance computing template function.">distance_operation</a>(bv1, bv2, &dmd, &dmd+1);

975

<a name="l00948"></a>00948 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

976

<a name="l00949"></a>00949 }

977

<a name="l00950"></a>00950

978

<a name="l00951"></a>00951 /*!

979

<a name="l00952"></a>00952 \brief Computes if there is any bit in AND operation of two bitsets

980

<a name="l00953"></a>00953 \param bv1 - Argument bit-vector.

981

<a name="l00954"></a>00954 \param bv2 - Argument bit-vector.

982

<a name="l00955"></a>00955 \return non zero value if there is any bit

983

<a name="l00956"></a>00956 \ingroup distance

984

<a name="l00957"></a>00957 */

985

<a name="l00958"></a>00958 template<class BV>

986

<a name="l00959"></a><a class="code" href="a00120.html#ga2d5393e05bcfc540840a4cee67fb771f">00959</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#ga2d5393e05bcfc540840a4cee67fb771f" title="Computes if there is any bit in AND operation of two bitsets.">any_and</a>(const BV& bv1, const BV& bv2)

987

<a name="l00960"></a>00960 {

988

<a name="l00961"></a>00961 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abacb39376469ba778e9a9099ddbae5e7ce" title="(A &amp; B).count()">bm::COUNT_AND</a>);

989

<a name="l00962"></a>00962

990

<a name="l00963"></a>00963 <a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e" title="Distance screening template function.">distance_operation_any</a>(bv1, bv2, &dmd, &dmd+1);

991

<a name="l00964"></a>00964 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

992

<a name="l00965"></a>00965 }

993

<a name="l00966"></a>00966

994

<a name="l00967"></a>00967

995

<a name="l00968"></a>00968

996

<a name="l00969"></a>00969 /*!

997

<a name="l00970"></a>00970 \brief Computes bitcount of XOR operation of two bitsets

998

<a name="l00971"></a>00971 \param bv1 - Argument bit-vector.

999

<a name="l00972"></a>00972 \param bv2 - Argument bit-vector.

1000

<a name="l00973"></a>00973 \return bitcount of the result

1001

<a name="l00974"></a>00974 \ingroup distance

1002

<a name="l00975"></a>00975 */

1003

<a name="l00976"></a>00976 template<class BV>

1004

<a name="l00977"></a><a class="code" href="a00120.html#gafc64a082dcaee07f70f7faf3e24f844e">00977</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#gafc64a082dcaee07f70f7faf3e24f844e" title="Computes bitcount of XOR operation of two bitsets.">count_xor</a>(const BV& bv1, const BV& bv2)

1005

<a name="l00978"></a>00978 {

1006

<a name="l00979"></a>00979 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>);

1007

<a name="l00980"></a>00980

1008

<a name="l00981"></a>00981 <a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b" title="Distance computing template function.">distance_operation</a>(bv1, bv2, &dmd, &dmd+1);

1009

<a name="l00982"></a>00982 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1010

<a name="l00983"></a>00983 }

1011

<a name="l00984"></a>00984

1012

<a name="l00985"></a>00985 /*!

1013

<a name="l00986"></a>00986 \brief Computes if there is any bit in XOR operation of two bitsets

1014

<a name="l00987"></a>00987 \param bv1 - Argument bit-vector.

1015

<a name="l00988"></a>00988 \param bv2 - Argument bit-vector.

1016

<a name="l00989"></a>00989 \return non zero value if there is any bit

1017

<a name="l00990"></a>00990 \ingroup distance

1018

<a name="l00991"></a>00991 */

1019

<a name="l00992"></a>00992 template<class BV>

1020

<a name="l00993"></a><a class="code" href="a00120.html#ga2d63f41244b82d233acb53d88b326b82">00993</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#ga2d63f41244b82d233acb53d88b326b82" title="Computes if there is any bit in XOR operation of two bitsets.">any_xor</a>(const BV& bv1, const BV& bv2)

1021

<a name="l00994"></a>00994 {

1022

<a name="l00995"></a>00995 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba3e4861dde6e1179457ee0d3502ae8061" title="(A ^ B).count()">bm::COUNT_XOR</a>);

1023

<a name="l00996"></a>00996

1024

<a name="l00997"></a>00997 <a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e" title="Distance screening template function.">distance_operation_any</a>(bv1, bv2, &dmd, &dmd+1);

1025

<a name="l00998"></a>00998 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1026

<a name="l00999"></a>00999 }

1027

<a name="l01000"></a>01000

1028

<a name="l01001"></a>01001

1029

<a name="l01002"></a>01002

1030

<a name="l01003"></a>01003 /*!

1031

<a name="l01004"></a>01004 \brief Computes bitcount of SUB operation of two bitsets

1032

<a name="l01005"></a>01005 \param bv1 - Argument bit-vector.

1033

<a name="l01006"></a>01006 \param bv2 - Argument bit-vector.

1034

<a name="l01007"></a>01007 \return bitcount of the result

1035

<a name="l01008"></a>01008 \ingroup distance

1036

<a name="l01009"></a>01009 */

1037

<a name="l01010"></a>01010 template<class BV>

1038

<a name="l01011"></a><a class="code" href="a00120.html#ga902d8c1cd1f8a2538cd47d47f5d8d605">01011</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#ga902d8c1cd1f8a2538cd47d47f5d8d605" title="Computes bitcount of SUB operation of two bitsets.">count_sub</a>(const BV& bv1, const BV& bv2)

1039

<a name="l01012"></a>01012 {

1040

<a name="l01013"></a>01013 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>);

1041

<a name="l01014"></a>01014

1042

<a name="l01015"></a>01015 <a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b" title="Distance computing template function.">distance_operation</a>(bv1, bv2, &dmd, &dmd+1);

1043

<a name="l01016"></a>01016 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1044

<a name="l01017"></a>01017 }

1045

<a name="l01018"></a>01018

1046

<a name="l01019"></a>01019

1047

<a name="l01020"></a>01020 /*!

1048

<a name="l01021"></a>01021 \brief Computes if there is any bit in SUB operation of two bitsets

1049

<a name="l01022"></a>01022 \param bv1 - Argument bit-vector.

1050

<a name="l01023"></a>01023 \param bv2 - Argument bit-vector.

1051

<a name="l01024"></a>01024 \return non zero value if there is any bit

1052

<a name="l01025"></a>01025 \ingroup distance

1053

<a name="l01026"></a>01026 */

1054

<a name="l01027"></a>01027 template<class BV>

1055

<a name="l01028"></a><a class="code" href="a00120.html#gabde2e210b9b1edd190e1f5a9ff22344c">01028</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#gabde2e210b9b1edd190e1f5a9ff22344c" title="Computes if there is any bit in SUB operation of two bitsets.">any_sub</a>(const BV& bv1, const BV& bv2)

1056

<a name="l01029"></a>01029 {

1057

<a name="l01030"></a>01030 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40aba9c101dab8904c0432f72ccce0a207e62" title="(A - B).count()">bm::COUNT_SUB_AB</a>);

1058

<a name="l01031"></a>01031

1059

<a name="l01032"></a>01032 <a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e" title="Distance screening template function.">distance_operation_any</a>(bv1, bv2, &dmd, &dmd+1);

1060

<a name="l01033"></a>01033 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1061

<a name="l01034"></a>01034 }

1062

<a name="l01035"></a>01035

1063

<a name="l01036"></a>01036

1064

<a name="l01037"></a>01037 /*!

1065

<a name="l01038"></a>01038 \brief Computes bitcount of OR operation of two bitsets

1066

<a name="l01039"></a>01039 \param bv1 - Argument bit-vector.

1067

<a name="l01040"></a>01040 \param bv2 - Argument bit-vector.

1068

<a name="l01041"></a>01041 \return bitcount of the result

1069

<a name="l01042"></a>01042 \ingroup distance

1070

<a name="l01043"></a>01043 */

1071

<a name="l01044"></a>01044 template<class BV>

1072

<a name="l01045"></a><a class="code" href="a00120.html#ga803c564668703fc3bf80067570c2c905">01045</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#ga803c564668703fc3bf80067570c2c905" title="Computes bitcount of OR operation of two bitsets.">count_or</a>(const BV& bv1, const BV& bv2)

1073

<a name="l01046"></a>01046 {

1074

<a name="l01047"></a>01047 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>);

1075

<a name="l01048"></a>01048

1076

<a name="l01049"></a>01049 <a class="code" href="a00120.html#ga815fef76f02576ab9ab58de0a45d8a4b" title="Distance computing template function.">distance_operation</a>(bv1, bv2, &dmd, &dmd+1);

1077

<a name="l01050"></a>01050 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1078

<a name="l01051"></a>01051 }

1079

<a name="l01052"></a>01052

1080

<a name="l01053"></a>01053 /*!

1081

<a name="l01054"></a>01054 \brief Computes if there is any bit in OR operation of two bitsets

1082

<a name="l01055"></a>01055 \param bv1 - Argument bit-vector.

1083

<a name="l01056"></a>01056 \param bv2 - Argument bit-vector.

1084

<a name="l01057"></a>01057 \return non zero value if there is any bit

1085

<a name="l01058"></a>01058 \ingroup distance

1086

<a name="l01059"></a>01059 */

1087

<a name="l01060"></a>01060 template<class BV>

1088

<a name="l01061"></a><a class="code" href="a00120.html#gaeda4f0cf54aa464cec09e740100caa79">01061</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00120.html#gaeda4f0cf54aa464cec09e740100caa79" title="Computes if there is any bit in OR operation of two bitsets.">any_or</a>(const BV& bv1, const BV& bv2)

1089

<a name="l01062"></a>01062 {

1090

<a name="l01063"></a>01063 <a class="code" href="a00060.html" title="Distance metric descriptor, holds metric code and result.">distance_metric_descriptor</a> dmd(<a class="code" href="a00120.html#ggac38d64c8b27b652413a664cddd4d40abad0bd2d56c8ebd03f55c01b3cc6faaaeb" title="(A | B).count()">bm::COUNT_OR</a>);

1091

<a name="l01064"></a>01064

1092

<a name="l01065"></a>01065 <a class="code" href="a00120.html#gaa66525fd7a3f823d73678252a235982e" title="Distance screening template function.">distance_operation_any</a>(bv1, bv2, &dmd, &dmd+1);

1093

<a name="l01066"></a>01066 return dmd.<a class="code" href="a00060.html#a94c955fe1ac46589d6edc8df7fd35cf6">result</a>;

1094

<a name="l01067"></a>01067 }

1095

<a name="l01068"></a>01068

1096

<a name="l01069"></a>01069

1097

<a name="l01070"></a>01070 /**

1098

<a name="l01071"></a>01071 \brief Internal algorithms scans the input for the block range limit

1099

<a name="l01072"></a>01072 \internal

1100

<a name="l01073"></a>01073 */

1101

<a name="l01074"></a>01074 template<class It>

1102

<a name="l01075"></a><a class="code" href="a00110.html#a86d5d5ccdb79d2b2ad552bd1caf34b2f">01075</a> It <a class="code" href="a00110.html#a86d5d5ccdb79d2b2ad552bd1caf34b2f" title="Internal algorithms scans the input for the block range limit.">block_range_scan</a>(It first, It last, unsigned nblock, unsigned* max_id)

1103

<a name="l01076"></a>01076 {

1104

<a name="l01077"></a>01077 It right;

1105

<a name="l01078"></a>01078 for (right = first; right != last; ++right)

1106

<a name="l01079"></a>01079 {

1107

<a name="l01080"></a>01080 unsigned v = unsigned(*right);

1108

<a name="l01081"></a>01081 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(v < <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

1109

<a name="l01082"></a>01082 if (v >= *max_id)

1110

<a name="l01083"></a>01083 *max_id = v;

1111

<a name="l01084"></a>01084 unsigned nb = v >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>;

1112

<a name="l01085"></a>01085 if (nb != nblock)

1113

<a name="l01086"></a>01086 break;

1114

<a name="l01087"></a>01087 }

1115

<a name="l01088"></a>01088 return right;

1116

<a name="l01089"></a>01089 }

1117

<a name="l01090"></a>01090

1118

<a name="l01091"></a>01091 /**

1119

<a name="l01092"></a>01092 \brief OR Combine bitvector and the iterable sequence

1120

<a name="l01093"></a>01093

1121

<a name="l01094"></a>01094 Algorithm combines bvector with sequence of integers

1122

<a name="l01095"></a>01095 (represents another set). When the agrument set is sorted

1123

<a name="l01096"></a>01096 this method can give serious increase in performance.

1124

<a name="l01097"></a>01097

1125

<a name="l01098"></a>01098 \param bv - destination bitvector

1126

<a name="l01099"></a>01099 \param first - first element of the iterated sequence

1127

<a name="l01100"></a>01100 \param last - last element of the iterated sequence

1128

<a name="l01101"></a>01101

1129

<a name="l01102"></a>01102 \ingroup setalgo

1130

<a name="l01103"></a>01103 */

1131

<a name="l01104"></a>01104 template<class BV, class It>

1132

<a name="l01105"></a><a class="code" href="a00119.html#ga54ff78528c99ae3ca443eb99ba44785b">01105</a> void <a class="code" href="a00119.html#ga54ff78528c99ae3ca443eb99ba44785b" title="OR Combine bitvector and the iterable sequence.">combine_or</a>(BV& bv, It first, It last)

1133

<a name="l01106"></a>01106 {

1134

<a name="l01107"></a>01107 typename BV::blocks_manager_type& bman = bv.get_blocks_manager();

1135

<a name="l01108"></a>01108 unsigned max_id = 0;

1136

<a name="l01109"></a>01109

1137

<a name="l01110"></a>01110 while (first < last)

1138

<a name="l01111"></a>01111 {

1139

<a name="l01112"></a>01112 unsigned nblock = unsigned((*first) >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1140

<a name="l01113"></a>01113 It right = <a class="code" href="a00110.html#a86d5d5ccdb79d2b2ad552bd1caf34b2f" title="Internal algorithms scans the input for the block range limit.">block_range_scan</a>(first, last, nblock, &max_id);

1141

<a name="l01114"></a>01114

1142

<a name="l01115"></a>01115 if (max_id >= bv.size())

1143

<a name="l01116"></a>01116 {

1144

<a name="l01117"></a>01117 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(max_id < <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

1145

<a name="l01118"></a>01118 bv.resize(max_id + 1);

1146

<a name="l01119"></a>01119 }

1147

<a name="l01120"></a>01120

1148

<a name="l01121"></a>01121 // now we have one in-block array of bits to set

1149

<a name="l01122"></a>01122

1150

<a name="l01123"></a>01123 label1:

1151

<a name="l01124"></a>01124

1152

<a name="l01125"></a>01125 int block_type;

1153

<a name="l01126"></a>01126 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1154

<a name="l01127"></a>01127 bman.check_allocate_block(nblock,

1155

<a name="l01128"></a>01128 true,

1156

<a name="l01129"></a>01129 bv.get_new_blocks_strat(),

1157

<a name="l01130"></a>01130 &block_type);

1158

<a name="l01131"></a>01131 if (!blk)

1159

<a name="l01132"></a>01132 continue;

1160

<a name="l01133"></a>01133

1161

<a name="l01134"></a>01134 if (block_type == 1) // gap

1162

<a name="l01135"></a>01135 {

1163

<a name="l01136"></a>01136 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

1164

<a name="l01137"></a>01137 unsigned threshold = <a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, bman.glen());

1165

<a name="l01138"></a>01138

1166

<a name="l01139"></a>01139 for (; first < right; ++first)

1167

<a name="l01140"></a>01140 {

1168

<a name="l01141"></a>01141 unsigned is_set;

1169

<a name="l01142"></a>01142 unsigned nbit = (*first) & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>;

1170

<a name="l01143"></a>01143

1171

<a name="l01144"></a>01144 unsigned new_block_len =

1172

<a name="l01145"></a>01145 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(true, gap_blk, nbit, &is_set);

1173

<a name="l01146"></a>01146 if (new_block_len > threshold)

1174

<a name="l01147"></a>01147 {

1175

<a name="l01148"></a>01148 bman.extend_gap_block(nblock, gap_blk);

1176

<a name="l01149"></a>01149 ++first;

1177

<a name="l01150"></a>01150 goto label1; // block pointer changed - goto reset

1178

<a name="l01151"></a>01151 }

1179

<a name="l01152"></a>01152 }

1180

<a name="l01153"></a>01153 }

1181

<a name="l01154"></a>01154 else // bit block

1182

<a name="l01155"></a>01155 {

1183

<a name="l01156"></a>01156 for (; first < right; ++first)

1184

<a name="l01157"></a>01157 {

1185

<a name="l01158"></a>01158 unsigned nbit = unsigned(*first & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1186

<a name="l01159"></a>01159 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1187

<a name="l01160"></a>01160 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1188

<a name="l01161"></a>01161 blk[nword] |= (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1 << nbit;

1189

<a name="l01162"></a>01162 } // for

1190

<a name="l01163"></a>01163 }

1191

<a name="l01164"></a>01164 } // while

1192

<a name="l01165"></a>01165

1193

<a name="l01166"></a>01166 bv.forget_count();

1194

<a name="l01167"></a>01167 }

1195

<a name="l01168"></a>01168

1196

<a name="l01169"></a>01169

1197

<a name="l01170"></a>01170 /**

1198

<a name="l01171"></a>01171 \brief XOR Combine bitvector and the iterable sequence

1199

<a name="l01172"></a>01172

1200

<a name="l01173"></a>01173 Algorithm combines bvector with sequence of integers

1201

<a name="l01174"></a>01174 (represents another set). When the agrument set is sorted

1202

<a name="l01175"></a>01175 this method can give serious increase in performance.

1203

<a name="l01176"></a>01176

1204

<a name="l01177"></a>01177 \param bv - destination bitvector

1205

<a name="l01178"></a>01178 \param first - first element of the iterated sequence

1206

<a name="l01179"></a>01179 \param last - last element of the iterated sequence

1207

<a name="l01180"></a>01180

1208

<a name="l01181"></a>01181 \ingroup setalgo

1209

<a name="l01182"></a>01182 */

1210

<a name="l01183"></a>01183 template<class BV, class It>

1211

<a name="l01184"></a><a class="code" href="a00119.html#ga3cb362aee03de6a321495100ae5c8375">01184</a> void <a class="code" href="a00119.html#ga3cb362aee03de6a321495100ae5c8375" title="XOR Combine bitvector and the iterable sequence.">combine_xor</a>(BV& bv, It first, It last)

1212

<a name="l01185"></a>01185 {

1213

<a name="l01186"></a>01186 typename BV::blocks_manager_type& bman = bv.get_blocks_manager();

1214

<a name="l01187"></a>01187 unsigned max_id = 0;

1215

<a name="l01188"></a>01188

1216

<a name="l01189"></a>01189 while (first < last)

1217

<a name="l01190"></a>01190 {

1218

<a name="l01191"></a>01191 unsigned nblock = unsigned((*first) >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1219

<a name="l01192"></a>01192 It right = <a class="code" href="a00110.html#a86d5d5ccdb79d2b2ad552bd1caf34b2f" title="Internal algorithms scans the input for the block range limit.">block_range_scan</a>(first, last, nblock, &max_id);

1220

<a name="l01193"></a>01193

1221

<a name="l01194"></a>01194 if (max_id >= bv.size())

1222

<a name="l01195"></a>01195 {

1223

<a name="l01196"></a>01196 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(max_id < <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

1224

<a name="l01197"></a>01197 bv.resize(max_id + 1);

1225

<a name="l01198"></a>01198 }

1226

<a name="l01199"></a>01199

1227

<a name="l01200"></a>01200 // now we have one in-block array of bits to set

1228

<a name="l01201"></a>01201

1229

<a name="l01202"></a>01202 label1:

1230

<a name="l01203"></a>01203

1231

<a name="l01204"></a>01204 int block_type;

1232

<a name="l01205"></a>01205 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1233

<a name="l01206"></a>01206 bman.check_allocate_block(nblock,

1234

<a name="l01207"></a>01207 true,

1235

<a name="l01208"></a>01208 bv.get_new_blocks_strat(),

1236

<a name="l01209"></a>01209 &block_type,

1237

<a name="l01210"></a>01210 false /* no null return */);

1238

<a name="l01211"></a>01211 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(blk);

1239

<a name="l01212"></a>01212

1240

<a name="l01213"></a>01213 if (block_type == 1) // gap

1241

<a name="l01214"></a>01214 {

1242

<a name="l01215"></a>01215 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

1243

<a name="l01216"></a>01216 unsigned threshold = <a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, bman.glen());

1244

<a name="l01217"></a>01217

1245

<a name="l01218"></a>01218 for (; first < right; ++first)

1246

<a name="l01219"></a>01219 {

1247

<a name="l01220"></a>01220 unsigned is_set;

1248

<a name="l01221"></a>01221 unsigned nbit = (*first) & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>;

1249

<a name="l01222"></a>01222

1250

<a name="l01223"></a>01223 is_set = <a class="code" href="a00114.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit);

1251

<a name="l01224"></a>01224 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(is_set <= 1);

1252

<a name="l01225"></a>01225 is_set ^= 1;

1253

<a name="l01226"></a>01226

1254

<a name="l01227"></a>01227 unsigned new_block_len =

1255

<a name="l01228"></a>01228 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(is_set, gap_blk, nbit, &is_set);

1256

<a name="l01229"></a>01229 if (new_block_len > threshold)

1257

<a name="l01230"></a>01230 {

1258

<a name="l01231"></a>01231 bman.extend_gap_block(nblock, gap_blk);

1259

<a name="l01232"></a>01232 ++first;

1260

<a name="l01233"></a>01233 goto label1; // block pointer changed - goto reset

1261

<a name="l01234"></a>01234 }

1262

<a name="l01235"></a>01235 }

1263

<a name="l01236"></a>01236 }

1264

<a name="l01237"></a>01237 else // bit block

1265

<a name="l01238"></a>01238 {

1266

<a name="l01239"></a>01239 for (; first < right; ++first)

1267

<a name="l01240"></a>01240 {

1268

<a name="l01241"></a>01241 unsigned nbit = unsigned(*first & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1269

<a name="l01242"></a>01242 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1270

<a name="l01243"></a>01243 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1271

<a name="l01244"></a>01244 blk[nword] ^= (<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1 << nbit;

1272

<a name="l01245"></a>01245 } // for

1273

<a name="l01246"></a>01246 }

1274

<a name="l01247"></a>01247 } // while

1275

<a name="l01248"></a>01248

1276

<a name="l01249"></a>01249 bv.forget_count();

1277

<a name="l01250"></a>01250 }

1278

<a name="l01251"></a>01251

1279

<a name="l01252"></a>01252

1280

<a name="l01253"></a>01253

1281

<a name="l01254"></a>01254 /**

1282

<a name="l01255"></a>01255 \brief SUB Combine bitvector and the iterable sequence

1283

<a name="l01256"></a>01256

1284

<a name="l01257"></a>01257 Algorithm combines bvector with sequence of integers

1285

<a name="l01258"></a>01258 (represents another set). When the agrument set is sorted

1286

<a name="l01259"></a>01259 this method can give serious increase in performance.

1287

<a name="l01260"></a>01260

1288

<a name="l01261"></a>01261 \param bv - destination bitvector

1289

<a name="l01262"></a>01262 \param first - first element of the iterated sequence

1290

<a name="l01263"></a>01263 \param last - last element of the iterated sequence

1291

<a name="l01264"></a>01264

1292

<a name="l01265"></a>01265 \ingroup setalgo

1293

<a name="l01266"></a>01266 */

1294

<a name="l01267"></a>01267 template<class BV, class It>

1295

<a name="l01268"></a><a class="code" href="a00119.html#gab88c5bf51484323e0139aa789d7f0b98">01268</a> void <a class="code" href="a00119.html#gab88c5bf51484323e0139aa789d7f0b98" title="SUB Combine bitvector and the iterable sequence.">combine_sub</a>(BV& bv, It first, It last)

1296

<a name="l01269"></a>01269 {

1297

<a name="l01270"></a>01270 typename BV::blocks_manager_type& bman = bv.get_blocks_manager();

1298

<a name="l01271"></a>01271 unsigned max_id = 0;

1299

<a name="l01272"></a>01272

1300

<a name="l01273"></a>01273 while (first < last)

1301

<a name="l01274"></a>01274 {

1302

<a name="l01275"></a>01275 unsigned nblock = unsigned((*first) >> <a class="code" href="a00110.html#ad8723fbeea6290d3daa8917ea7ce9bb2">bm::set_block_shift</a>);

1303

<a name="l01276"></a>01276 It right = <a class="code" href="a00110.html#a86d5d5ccdb79d2b2ad552bd1caf34b2f" title="Internal algorithms scans the input for the block range limit.">block_range_scan</a>(first, last, nblock, &max_id);

1304

<a name="l01277"></a>01277

1305

<a name="l01278"></a>01278 if (max_id >= bv.size())

1306

<a name="l01279"></a>01279 {

1307

<a name="l01280"></a>01280 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(max_id < <a class="code" href="a00110.html#a104b924a1df81542db2a6296fbf26a65">bm::id_max</a>);

1308

<a name="l01281"></a>01281 bv.resize(max_id + 1);

1309

<a name="l01282"></a>01282 }

1310

<a name="l01283"></a>01283

1311

<a name="l01284"></a>01284 // now we have one in-block array of bits to set

1312

<a name="l01285"></a>01285

1313

<a name="l01286"></a>01286 label1:

1314

<a name="l01287"></a>01287

1315

<a name="l01288"></a>01288 int block_type;

1316

<a name="l01289"></a>01289 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1317

<a name="l01290"></a>01290 bman.check_allocate_block(nblock,

1318

<a name="l01291"></a>01291 false,

1319

<a name="l01292"></a>01292 bv.get_new_blocks_strat(),

1320

<a name="l01293"></a>01293 &block_type);

1321

<a name="l01294"></a>01294

1322

<a name="l01295"></a>01295 if (!blk)

1323

<a name="l01296"></a>01296 continue;

1324

<a name="l01297"></a>01297

1325

<a name="l01298"></a>01298 if (block_type == 1) // gap

1326

<a name="l01299"></a>01299 {

1327

<a name="l01300"></a>01300 <a class="code" href="a00110.html#ac654d6319039a86546d235a236fc7cf6">bm::gap_word_t</a>* gap_blk = <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk);

1328

<a name="l01301"></a>01301 unsigned threshold = <a class="code" href="a00114.html#ga94a5371b5dc6a1560d95d7c2dde88815" title="Returs GAP block capacity limit.">bm::gap_limit</a>(gap_blk, bman.glen());

1329

<a name="l01302"></a>01302

1330

<a name="l01303"></a>01303 for (; first < right; ++first)

1331

<a name="l01304"></a>01304 {

1332

<a name="l01305"></a>01305 unsigned is_set;

1333

<a name="l01306"></a>01306 unsigned nbit = (*first) & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>;

1334

<a name="l01307"></a>01307

1335

<a name="l01308"></a>01308 is_set = <a class="code" href="a00114.html#ga866352ef5986a7d2b709795d127b666b" title="Tests if bit = pos is true.">gap_test</a>(gap_blk, nbit);

1336

<a name="l01309"></a>01309 if (!is_set)

1337

<a name="l01310"></a>01310 continue;

1338

<a name="l01311"></a>01311

1339

<a name="l01312"></a>01312 unsigned new_block_len =

1340

<a name="l01313"></a>01313 <a class="code" href="a00114.html#ga69186bd13bda27e04b3e33683ff884c2" title="Abstract distance(similarity) operation for GAP buffers. Receives functor F as a...">gap_set_value</a>(false, gap_blk, nbit, &is_set);

1341

<a name="l01314"></a>01314 if (new_block_len > threshold)

1342

<a name="l01315"></a>01315 {

1343

<a name="l01316"></a>01316 bman.extend_gap_block(nblock, gap_blk);

1344

<a name="l01317"></a>01317 ++first;

1345

<a name="l01318"></a>01318 goto label1; // block pointer changed - goto reset

1346

<a name="l01319"></a>01319 }

1347

<a name="l01320"></a>01320 }

1348

<a name="l01321"></a>01321 }

1349

<a name="l01322"></a>01322 else // bit block

1350

<a name="l01323"></a>01323 {

1351

<a name="l01324"></a>01324 for (; first < right; ++first)

1352

<a name="l01325"></a>01325 {

1353

<a name="l01326"></a>01326 unsigned nbit = unsigned(*first & <a class="code" href="a00110.html#a201fb8b1f81b7487f1c1c129fc3d6557">bm::set_block_mask</a>);

1354

<a name="l01327"></a>01327 unsigned nword = unsigned(nbit >> <a class="code" href="a00110.html#a83d76bccf6fe3770f32d5ba11d2a37ad">bm::set_word_shift</a>);

1355

<a name="l01328"></a>01328 nbit &= <a class="code" href="a00110.html#addbf345be3733d5e4575d71733ed1da8">bm::set_word_mask</a>;

1356

<a name="l01329"></a>01329 blk[nword] &= ~((<a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>)1 << nbit);

1357

<a name="l01330"></a>01330 } // for

1358

<a name="l01331"></a>01331 }

1359

<a name="l01332"></a>01332 } // while

1360

<a name="l01333"></a>01333

1361

<a name="l01334"></a>01334 bv.forget_count();

1362

<a name="l01335"></a>01335 }

1363

<a name="l01336"></a>01336

1364

<a name="l01337"></a>01337 /**

1365

<a name="l01338"></a>01338 \brief AND Combine bitvector and the iterable sequence

1366

<a name="l01339"></a>01339

1367

<a name="l01340"></a>01340 Algorithm combines bvector with sorted sequence of integers

1368

<a name="l01341"></a>01341 (represents another set).

1369

<a name="l01342"></a>01342

1370

<a name="l01343"></a>01343 \param bv - destination bitvector

1371

<a name="l01344"></a>01344 \param first - first element of the iterated sequence

1372

<a name="l01345"></a>01345 \param last - last element of the iterated sequence

1373

<a name="l01346"></a>01346

1374

<a name="l01347"></a>01347 \ingroup setalgo

1375

<a name="l01348"></a>01348 */

1376

<a name="l01349"></a>01349 template<class BV, class It>

1377

<a name="l01350"></a><a class="code" href="a00119.html#ga22922f71bd1eec8a5b663dc77b90cf6c">01350</a> void <a class="code" href="a00119.html#ga22922f71bd1eec8a5b663dc77b90cf6c" title="AND Combine bitvector and the iterable sequence.">combine_and_sorted</a>(BV& bv, It first, It last)

1378

<a name="l01351"></a>01351 {

1379

<a name="l01352"></a>01352 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> prev = 0;

1380

<a name="l01353"></a>01353 for ( ;first < last; ++first)

1381

<a name="l01354"></a>01354 {

1382

<a name="l01355"></a>01355 <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> id = *first;

1383

<a name="l01356"></a>01356 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(id >= prev); // make sure it's sorted

1384

<a name="l01357"></a>01357 bv.set_bit_and(id, true);

1385

<a name="l01358"></a>01358 if (++prev < id)

1386

<a name="l01359"></a>01359 {

1387

<a name="l01360"></a>01360 bv.set_range(prev, id-1, false);

1388

<a name="l01361"></a>01361 }

1389

<a name="l01362"></a>01362 prev = id;

1390

<a name="l01363"></a>01363 }

1391

<a name="l01364"></a>01364 }

1392

<a name="l01365"></a>01365

1393

<a name="l01366"></a>01366

1394

<a name="l01367"></a>01367 /**

1395

<a name="l01368"></a>01368 \brief AND Combine bitvector and the iterable sequence

1396

<a name="l01369"></a>01369

1397

<a name="l01370"></a>01370 Algorithm combines bvector with sequence of integers

1398

<a name="l01371"></a>01371 (represents another set). When the agrument set is sorted

1399

<a name="l01372"></a>01372 this method can give serious increase in performance.

1400

<a name="l01373"></a>01373

1401

<a name="l01374"></a>01374 \param bv - destination bitvector

1402

<a name="l01375"></a>01375 \param first - first element of the iterated sequence

1403

<a name="l01376"></a>01376 \param last - last element of the iterated sequence

1404

<a name="l01377"></a>01377

1405

<a name="l01378"></a>01378 \ingroup setalgo

1406

<a name="l01379"></a>01379 \sa combine_and_sorted

1407

<a name="l01380"></a>01380 */

1408

<a name="l01381"></a>01381 template<class BV, class It>

1409

<a name="l01382"></a><a class="code" href="a00119.html#ga819bdab57a624a08456ea79161b9c5d2">01382</a> void <a class="code" href="a00119.html#ga819bdab57a624a08456ea79161b9c5d2" title="AND Combine bitvector and the iterable sequence.">combine_and</a>(BV& bv, It first, It last)

1410

<a name="l01383"></a>01383 {

1411

<a name="l01384"></a>01384 BV bv_tmp;

1412

<a name="l01385"></a>01385 <a class="code" href="a00119.html#ga54ff78528c99ae3ca443eb99ba44785b" title="OR Combine bitvector and the iterable sequence.">combine_or</a>(bv_tmp, first, last);

1413

<a name="l01386"></a>01386 bv &= bv_tmp;

1414

<a name="l01387"></a>01387 }

1415

<a name="l01388"></a>01388

1416

<a name="l01389"></a>01389 /*!

1417

<a name="l01390"></a>01390 \brief Compute number of bit intervals (GAPs) in the bitvector

1418

<a name="l01391"></a>01391

1419

<a name="l01392"></a>01392 Algorithm traverses bit vector and count number of uninterrupted

1420

<a name="l01393"></a>01393 intervals of 1s and 0s.

1421

1422

<a name="l01395"></a>01395 For example:

1423

<a name="l01396"></a>01396 00001111100000 - gives us 3 intervals

1424

<a name="l01397"></a>01397 10001111100000 - 4 intervals

1425

<a name="l01398"></a>01398 00000000000000 - 1 interval

1426

<a name="l01399"></a>01399 11111111111111 - 1 interval

1427

1428

<a name="l01401"></a>01401 \return Number of intervals

1429

<a name="l01402"></a>01402 \ingroup setalgo

1430

<a name="l01403"></a>01403 */

1431

<a name="l01404"></a>01404 template<class BV>

1432

<a name="l01405"></a><a class="code" href="a00119.html#gac7a59d3bc266310ec127cb3efadb0d33">01405</a> <a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a> <a class="code" href="a00119.html#gac7a59d3bc266310ec127cb3efadb0d33" title="Compute number of bit intervals (GAPs) in the bitvector.">count_intervals</a>(const BV& bv)

1433

<a name="l01406"></a>01406 {

1434

<a name="l01407"></a>01407 const typename BV::blocks_manager_type& bman = bv.get_blocks_manager();

1435

<a name="l01408"></a>01408

1436

<a name="l01409"></a>01409 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>*** blk_root = bman.get_rootblock();

1437

<a name="l01410"></a>01410 typename BV::blocks_manager_type::block_count_change_func func(bman);

1438

<a name="l01411"></a>01411 <a class="code" href="a00110.html#a86742a3e17527be5a9743f26b36a7691">for_each_block</a>(blk_root, bman.top_block_size(), <a class="code" href="a00110.html#a40ad34d6c46a2fb20ba2baa7f95d80b4">bm::set_array_size</a>, func);

1439

<a name="l01412"></a>01412

1440

<a name="l01413"></a>01413 return func.count();

1441

<a name="l01414"></a>01414 }

1442

<a name="l01415"></a>01415

1443

<a name="l01416"></a>01416 /*!

1444

<a name="l01417"></a>01417 \brief Export bitset from an array of binary data representing

1445

<a name="l01418"></a>01418 the bit vector.

1446

<a name="l01419"></a>01419

1447

<a name="l01420"></a>01420 Input array can be array of ints, chars or other native C types.

1448

<a name="l01421"></a>01421 Method works with iterators, which makes it compatible with

1449

<a name="l01422"></a>01422 STL containers and C arrays

1450

<a name="l01423"></a>01423

1451

<a name="l01424"></a>01424 \param bv - destination bitvector

1452

<a name="l01425"></a>01425 \param first - first element of the iterated sequence

1453

<a name="l01426"></a>01426 \param last - last element of the iterated sequence

1454

<a name="l01427"></a>01427

1455

<a name="l01428"></a>01428 \ingroup setalgo

1456

<a name="l01429"></a>01429 */

1457

<a name="l01430"></a>01430 template<class BV, class It>

1458

<a name="l01431"></a><a class="code" href="a00119.html#gacd88ed9539553dd93419b7029e8a4584">01431</a> void <a class="code" href="a00119.html#gacd88ed9539553dd93419b7029e8a4584" title="Export bitset from an array of binary data representing the bit vector.">export_array</a>(BV& bv, It first, It last)

1459

<a name="l01432"></a>01432 {

1460

<a name="l01433"></a>01433 typename BV::blocks_manager_type& bman = bv.get_blocks_manager();

1461

<a name="l01434"></a>01434 unsigned inp_word_size = sizeof(*first);

1462

<a name="l01435"></a>01435 size_t array_size = last - first;

1463

<a name="l01436"></a>01436 size_t bit_cnt = array_size * inp_word_size * 8;

1464

<a name="l01437"></a>01437 int block_type;

1465

<a name="l01438"></a>01438 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a> tmp;

1466

<a name="l01439"></a>01439 unsigned b1, b2, b3, b4;

1467

<a name="l01440"></a>01440

1468

<a name="l01441"></a>01441 if (bit_cnt >= bv.size())

1469

<a name="l01442"></a>01442 bv.resize((<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a>)bit_cnt + 1);

1470

<a name="l01443"></a>01443 else

1471

<a name="l01444"></a>01444 bv.set_range((<a class="code" href="a00110.html#aa3824d882a037396370b16f2f0a8bf37">bm::id_t</a>)bit_cnt, bv.size() - 1, false);

1472

<a name="l01445"></a>01445

1473

<a name="l01446"></a>01446 switch (inp_word_size)

1474

<a name="l01447"></a>01447 {

1475

<a name="l01448"></a>01448 case 1:

1476

<a name="l01449"></a>01449 {

1477

<a name="l01450"></a>01450 size_t word_cnt = array_size / 4;

1478

<a name="l01451"></a>01451 for (unsigned i = 0; i < <a class="code" href="a00110.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>; ++i)

1479

<a name="l01452"></a>01452 {

1480

<a name="l01453"></a>01453 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1481

<a name="l01454"></a>01454 bman.check_allocate_block(i,

1482

<a name="l01455"></a>01455 false,

1483

<a name="l01456"></a>01456 <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

1484

<a name="l01457"></a>01457 &block_type,

1485

<a name="l01458"></a>01458 false /*no NULL ret*/);

1486

<a name="l01459"></a>01459 if (block_type == 1) // gap

1487

<a name="l01460"></a>01460 {

1488

<a name="l01461"></a>01461 blk = bman.convert_gap2bitset(i, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

1489

<a name="l01462"></a>01462 }

1490

<a name="l01463"></a>01463

1491

<a name="l01464"></a>01464 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_ptr = blk;

1492

<a name="l01465"></a>01465 if (word_cnt >= <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>) {

1493

<a name="l01466"></a>01466 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_end = blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

1494

<a name="l01467"></a>01467 do {

1495

<a name="l01468"></a>01468 b1 = *first++; b2 = *first++;

1496

<a name="l01469"></a>01469 b3 = *first++; b4 = *first++;

1497

<a name="l01470"></a>01470 tmp = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);

1498

<a name="l01471"></a>01471 *wrd_ptr++ = tmp;

1499

<a name="l01472"></a>01472 } while (wrd_ptr < wrd_end);

1500

<a name="l01473"></a>01473 word_cnt -= bm::set_block_size;

1501

<a name="l01474"></a>01474 }

1502

<a name="l01475"></a>01475 else

1503

<a name="l01476"></a>01476 {

1504

<a name="l01477"></a>01477 size_t to_convert = last - first;

1505

<a name="l01478"></a>01478 for (size_t j = 0; j < to_convert / 4; ++j)

1506

<a name="l01479"></a>01479 {

1507

<a name="l01480"></a>01480 b1 = *first++; b2 = *first++;

1508

<a name="l01481"></a>01481 b3 = *first++; b4 = *first++;

1509

<a name="l01482"></a>01482 tmp = b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);

1510

<a name="l01483"></a>01483 *wrd_ptr++ = tmp;

1511

<a name="l01484"></a>01484 }

1512

<a name="l01485"></a>01485 while (1)

1513

<a name="l01486"></a>01486 {

1514

<a name="l01487"></a>01487 if (first == last) break;

1515

<a name="l01488"></a>01488 *wrd_ptr = *first++;

1516

<a name="l01489"></a>01489 if (first == last) break;

1517

<a name="l01490"></a>01490 *wrd_ptr |= (*first++) << 8;

1518

<a name="l01491"></a>01491 if (first == last) break;

1519

<a name="l01492"></a>01492 *wrd_ptr |= (*first++) << 16;

1520

<a name="l01493"></a>01493 if (first == last) break;

1521

<a name="l01494"></a>01494 *wrd_ptr |= (*first++) << 24;

1522

<a name="l01495"></a>01495 ++wrd_ptr;

1523

<a name="l01496"></a>01496 }

1524

<a name="l01497"></a>01497 }

1525

<a name="l01498"></a>01498 if (first == last) break;

1526

<a name="l01499"></a>01499 } // for

1527

<a name="l01500"></a>01500 }

1528

<a name="l01501"></a>01501 break;

1529

<a name="l01502"></a>01502 case 2:

1530

<a name="l01503"></a>01503 {

1531

<a name="l01504"></a>01504 size_t word_cnt = array_size / 2;

1532

<a name="l01505"></a>01505 for (unsigned i = 0; i < <a class="code" href="a00110.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>; ++i)

1533

<a name="l01506"></a>01506 {

1534

<a name="l01507"></a>01507 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1535

<a name="l01508"></a>01508 bman.check_allocate_block(i,

1536

<a name="l01509"></a>01509 false,

1537

<a name="l01510"></a>01510 <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

1538

<a name="l01511"></a>01511 &block_type,

1539

<a name="l01512"></a>01512 false /*no NULL ret*/);

1540

<a name="l01513"></a>01513 if (block_type == 1) // gap

1541

<a name="l01514"></a>01514 {

1542

<a name="l01515"></a>01515 blk = bman.convert_gap2bitset(i, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

1543

<a name="l01516"></a>01516 }

1544

<a name="l01517"></a>01517

1545

<a name="l01518"></a>01518 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_ptr = blk;

1546

<a name="l01519"></a>01519 if (word_cnt >= <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>) {

1547

<a name="l01520"></a>01520 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_end = blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

1548

<a name="l01521"></a>01521 do {

1549

<a name="l01522"></a>01522 b1 = *first++; b2 = *first++;

1550

<a name="l01523"></a>01523 tmp = b1 | (b2 << 16);

1551

<a name="l01524"></a>01524 *wrd_ptr++ = tmp;

1552

<a name="l01525"></a>01525 } while (wrd_ptr < wrd_end);

1553

<a name="l01526"></a>01526 word_cnt -= bm::set_block_size;

1554

<a name="l01527"></a>01527 }

1555

<a name="l01528"></a>01528 else

1556

<a name="l01529"></a>01529 {

1557

<a name="l01530"></a>01530 size_t to_convert = last - first;

1558

<a name="l01531"></a>01531 for (unsigned j = 0; j < to_convert / 2; ++j)

1559

<a name="l01532"></a>01532 {

1560

<a name="l01533"></a>01533 b1 = *first++; b2 = *first++;

1561

<a name="l01534"></a>01534 tmp = b1 | (b2 << 16);

1562

<a name="l01535"></a>01535 *wrd_ptr++ = tmp;

1563

<a name="l01536"></a>01536 }

1564

<a name="l01537"></a>01537 while (1)

1565

<a name="l01538"></a>01538 {

1566

<a name="l01539"></a>01539 if (first == last) break;

1567

<a name="l01540"></a>01540 *wrd_ptr = *first++;

1568

<a name="l01541"></a>01541 if (first == last) break;

1569

<a name="l01542"></a>01542 *wrd_ptr |= (*first++) << 16;

1570

<a name="l01543"></a>01543 ++wrd_ptr;

1571

<a name="l01544"></a>01544 }

1572

<a name="l01545"></a>01545 }

1573

<a name="l01546"></a>01546 if (first == last) break;

1574

<a name="l01547"></a>01547 } // for

1575

<a name="l01548"></a>01548 }

1576

<a name="l01549"></a>01549 break;

1577

<a name="l01550"></a>01550 case 4:

1578

<a name="l01551"></a>01551 {

1579

<a name="l01552"></a>01552 size_t word_cnt = array_size;

1580

<a name="l01553"></a>01553 for (unsigned i = 0; i < <a class="code" href="a00110.html#a505011007f54598794e0b9477c0b0b11">bm::set_total_blocks</a>; ++i)

1581

<a name="l01554"></a>01554 {

1582

<a name="l01555"></a>01555 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* blk =

1583

<a name="l01556"></a>01556 bman.check_allocate_block(i,

1584

<a name="l01557"></a>01557 false,

1585

<a name="l01558"></a>01558 <a class="code" href="a00113.html#ggad0b87b3b7292383a864d27feaf1c9effa40920ae0ef7b4411d60463d8f576b5ba" title="No GAP compression strategy. All new blocks are bit blocks.">BM_BIT</a>,

1586

<a name="l01559"></a>01559 &block_type,

1587

<a name="l01560"></a>01560 false /*no NULL ret*/);

1588

<a name="l01561"></a>01561 if (block_type == 1) // gap

1589

<a name="l01562"></a>01562 {

1590

<a name="l01563"></a>01563 blk = bman.convert_gap2bitset(i, <a class="code" href="a00089.html#a6a7c8b8ee3f3b60ab907c1699acb7aa0">BMGAP_PTR</a>(blk));

1591

<a name="l01564"></a>01564 }

1592

<a name="l01565"></a>01565

1593

<a name="l01566"></a>01566 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_ptr = blk;

1594

<a name="l01567"></a>01567 if (word_cnt >= <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>) {

1595

<a name="l01568"></a>01568 <a class="code" href="a00110.html#a17fd5ba52db3ddda05e6f8dd5000a1a4">bm::word_t</a>* wrd_end = blk + <a class="code" href="a00110.html#a91319dbc0d0e1bf3a3efc4d92bac7972">bm::set_block_size</a>;

1596

<a name="l01569"></a>01569 do {

1597

<a name="l01570"></a>01570 *wrd_ptr++ = *first++;

1598

<a name="l01571"></a>01571 } while (wrd_ptr < wrd_end);

1599

<a name="l01572"></a>01572 word_cnt -= bm::set_block_size;

1600

<a name="l01573"></a>01573 }

1601

<a name="l01574"></a>01574 else

1602

<a name="l01575"></a>01575 {

1603

<a name="l01576"></a>01576 while (1)

1604

<a name="l01577"></a>01577 {

1605

<a name="l01578"></a>01578 if (first == last) break;

1606

<a name="l01579"></a>01579 *wrd_ptr = *first++;

1607

<a name="l01580"></a>01580 ++wrd_ptr;

1608

<a name="l01581"></a>01581 }

1609

<a name="l01582"></a>01582 }

1610

<a name="l01583"></a>01583 if (first == last) break;

1611

<a name="l01584"></a>01584 } // for

1612

<a name="l01585"></a>01585 }

1613

<a name="l01586"></a>01586 break;

1614

<a name="l01587"></a>01587 default:

1615

<a name="l01588"></a>01588 <a class="code" href="a00089.html#aa44515fab0ace8928d1cb82009a95bf8">BM_ASSERT</a>(0);

1616

<a name="l01589"></a>01589 } // switch

1617

<a name="l01590"></a>01590

1618

<a name="l01591"></a>01591 }

1619

<a name="l01592"></a>01592

1620

<a name="l01593"></a>01593 } // namespace bm

1621

<a name="l01594"></a>01594

1622

<a name="l01595"></a>01595 #ifdef _MSC_VER

1623

<a name="l01596"></a>01596 #pragma warning( default : 4311 4312)

1624

<a name="l01597"></a>01597 #endif

1625

<a name="l01598"></a>01598

1626

<a name="l01599"></a>01599 #endif

1627

</pre></div></div>

1628

<hr size="1"/><address style="text-align: right;">Generated on Sun Nov 22 10:49:35 2009 for BitMagic by

1629

1630

1631

</body>

1632

</html>

Older »