--- /dev/null
+/* static_bitsequence_builder_rrr02_light.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_builder_rrr02_light definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_bitsequence_builder_rrr02_light.h>
+
+static_bitsequence_builder_rrr02_light::static_bitsequence_builder_rrr02_light(uint sampling) {
+ sample_rate=sampling;
+}
+
+static_bitsequence * static_bitsequence_builder_rrr02_light::build(uint * bitsequence, uint len) {
+ return new static_bitsequence_rrr02_light(bitsequence,len,sample_rate);
+}
--- /dev/null
+/* static_bitsequence_builder_rrr02_light.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_builder_rrr02_light definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_BITSEQUENCE_BUILDER_RRR02_LIGHT_H
+#define _STATIC_BITSEQUENCE_BUILDER_RRR02_LIGHT_H
+
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+
+class static_bitsequence_builder_rrr02_light : public static_bitsequence_builder {
+ public:
+ /** Defines the sample rate used to build the bitmaps (rrr02) */
+ static_bitsequence_builder_rrr02_light(uint sampling);
+ virtual ~static_bitsequence_builder_rrr02_light() {}
+ virtual static_bitsequence * build(uint * bitsequence, uint len);
+
+ protected:
+ uint sample_rate;
+};
+
+#endif /* _STATIC_BITSEQUENCE_BUILDER_RRR02_LIGHT_H */
--- /dev/null
+/* static_bitsequence_rrr02_light.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_rrr02_light definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_bitsequence_rrr02_light.h>
+
+#define VARS_NEEDED uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);\
+uint C_field_bits = bits(BLOCK_SIZE_LIGHT);\
+uint O_len = uint_len(1,O_bits_len);\
+uint C_sampling_len = C_len/sample_rate+2;\
+uint C_sampling_field_bits = bits(ones);\
+uint O_pos_len = C_len/sample_rate+1;\
+uint O_pos_field_bits = bits(O_bits_len);
+
+
+table_offset * static_bitsequence_rrr02_light::E = NULL;
+
+static_bitsequence_rrr02_light::static_bitsequence_rrr02_light() {
+ ones=0;
+ len=0;
+ if(E==NULL) E = new table_offset(BLOCK_SIZE_LIGHT);
+ E->use();
+ C = NULL;
+ O = NULL;
+ C_sampling = NULL;
+ O_pos = NULL;
+ sample_rate = DEFAULT_SAMPLING_LIGHT;
+ O_bits_len = 0;
+}
+
+static_bitsequence_rrr02_light::static_bitsequence_rrr02_light(uint * bitseq, uint len, uint sample_rate) {
+ ones = 0;
+ this->len = len;
+ if(E==NULL) E = new table_offset(BLOCK_SIZE_LIGHT);
+ E->use();
+ // Table C
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ C = new uint[uint_len(C_len,C_field_bits)];
+ for(uint i=0;i<uint_len(C_len,C_field_bits);i++)
+ C[i] = 0;
+ O_bits_len = 0;
+ for(uint i=0;i<C_len;i++) {
+ uint value = popcount(get_var_field(bitseq,i*BLOCK_SIZE_LIGHT,min((uint)len-1,(i+1)*BLOCK_SIZE_LIGHT-1)));
+ assert(value<=BLOCK_SIZE_LIGHT);
+ set_field(C,C_field_bits,i,value);
+ ones += value;
+ O_bits_len += E->get_log2binomial(BLOCK_SIZE_LIGHT,value);
+ }
+ // Table O
+ uint O_len = uint_len(1,O_bits_len);
+ O = new uint[O_len];
+ for(uint i=0;i<O_len;i++)
+ O[i] = 0;
+ uint O_pos = 0;
+ for(uint i=0;i<C_len;i++) {
+ uint value = (ushort)get_var_field(bitseq,i*BLOCK_SIZE_LIGHT,min((uint)len-1,(i+1)*BLOCK_SIZE_LIGHT-1));
+ set_var_field(O,O_pos,O_pos+E->get_log2binomial(BLOCK_SIZE_LIGHT,popcount(value))-1,E->compute_offset((ushort)value));
+ O_pos += E->get_log2binomial(BLOCK_SIZE_LIGHT,popcount(value));
+ }
+ C_sampling = NULL;
+ this->O_pos = NULL;
+
+ create_sampling(sample_rate);
+}
+
+void static_bitsequence_rrr02_light::create_sampling(uint sample_rate) {
+ this->sample_rate = sample_rate;
+/* for(uint i=0;i<C_len;i++) {
+ O_bits_len += E->get_log2binomial(BLOCK_SIZE_LIGHT,get_field(C,C_field_bits,i));
+ }*/
+ // Sampling for C
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint C_sampling_len = C_len/sample_rate+2;
+ uint C_sampling_field_bits = bits(ones);
+ if(C_sampling!=NULL) delete [] C_sampling;
+ C_sampling = new uint[max((uint)1,uint_len(C_sampling_len,C_sampling_field_bits))];
+ for(uint i=0;i<max((uint)1,uint_len(C_sampling_len,C_sampling_field_bits));i++)
+ C_sampling[i] = 0;
+ uint sum = 0;
+ for(uint i=0;i<C_len;i++) {
+ if(i%sample_rate==0)
+ set_field(C_sampling,C_sampling_field_bits,i/sample_rate,sum);
+ sum += get_field(C,C_field_bits,i);
+ }
+ for(uint i=(C_len-1)/sample_rate+1;i<C_sampling_len;i++)
+ set_field(C_sampling,C_sampling_field_bits,i,sum);
+ // Sampling for O (table S) (Code separated from previous construction for readability)
+ uint O_pos_len = C_len/sample_rate+1;
+ uint O_pos_field_bits = bits(O_bits_len);
+ if(O_pos!=NULL) delete [] O_pos;
+ O_pos = new uint[uint_len(O_pos_len,O_pos_field_bits)];
+ for(uint i=0;i<uint_len(O_pos_len,O_pos_field_bits);i++)
+ O_pos[i] = 0;
+ uint pos = 0;
+ for(uint i=0;i<C_len;i++) {
+ if(i%sample_rate==0)
+ set_field(O_pos,O_pos_field_bits,i/sample_rate,pos);
+ pos += E->get_log2binomial(BLOCK_SIZE_LIGHT,get_field(C,C_field_bits,i));
+ }
+}
+
+bool static_bitsequence_rrr02_light::access(uint i) {
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint O_pos_field_bits = bits(O_bits_len);
+ uint nearest_sampled_value = i/BLOCK_SIZE_LIGHT/sample_rate;
+ uint pos_O = get_field(O_pos,O_pos_field_bits,nearest_sampled_value);
+ uint pos = i/BLOCK_SIZE_LIGHT;
+ assert(pos<=C_len);
+ for(uint k=nearest_sampled_value*sample_rate;k<pos;k++) {
+ uint aux = get_field(C,C_field_bits,k);
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,aux);
+ }
+ uint c = get_field(C,C_field_bits,pos);
+ return ((1<<(i%BLOCK_SIZE_LIGHT))&E->short_bitmap(c,get_var_field(O,pos_O,pos_O+E->get_log2binomial(BLOCK_SIZE_LIGHT,c)-1)))!=0;
+}
+
+uint static_bitsequence_rrr02_light::rank0(uint i) {
+ if(i+1==0) return 0;
+ return 1+i-rank1(i);
+}
+
+uint static_bitsequence_rrr02_light::rank1(uint i) {
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint C_sampling_field_bits = bits(ones);
+ uint O_pos_field_bits = bits(O_bits_len);
+ if(i+1==0) return 0;
+ uint nearest_sampled_value = i/BLOCK_SIZE_LIGHT/sample_rate;
+ uint sum = get_field(C_sampling,C_sampling_field_bits,nearest_sampled_value);
+ uint pos_O = get_field(O_pos,O_pos_field_bits,nearest_sampled_value);
+ uint pos = i/BLOCK_SIZE_LIGHT;
+ uint k=nearest_sampled_value*sample_rate;
+ if(k%2==1 && k<pos) {
+ uint aux = get_field(C,C_field_bits,k);
+ sum += aux;
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,aux);
+ k++;
+ }
+ uchar * a = (uchar *)C;
+ uint mask = 0x0F;
+ a += k/2;
+ while(k<(uint)max(0,(int)pos-1)) {
+ assert(((*a)&mask)==get_field(C,C_field_bits,k));
+ assert((*a)/16==get_field(C,C_field_bits,k+1));
+ sum += ((*a)&mask)+(*a)/16;
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,((*a)&mask))+E->get_log2binomial(BLOCK_SIZE_LIGHT,((*a)/16));
+ a++;
+ k+=2;
+ }
+ if(k<pos) {
+ uint aux = get_field(C,C_field_bits,k);
+ sum += aux;
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,aux);
+ k++;
+ }
+ uint c = get_field(C,C_field_bits,pos);
+ sum += popcount(((2<<(i%BLOCK_SIZE_LIGHT))-1) & E->short_bitmap(c,get_var_field(O,pos_O,pos_O+E->get_log2binomial(BLOCK_SIZE_LIGHT,c)-1)));
+ return sum;
+}
+
+uint static_bitsequence_rrr02_light::select0(uint i) {
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint C_sampling_len = C_len/sample_rate+2;
+ uint C_sampling_field_bits = bits(ones);
+ uint O_pos_field_bits = bits(O_bits_len);
+ if(i==0) return -1;
+ if(i>len-ones) return len;
+ // Search over partial sums
+ uint start=0;
+ uint end=C_sampling_len-1;
+ uint med, acc=0, pos;
+ while(start<end-1) {
+ med = (start+end)/2;
+ acc = med*sample_rate*BLOCK_SIZE_LIGHT-get_field(C_sampling,C_sampling_field_bits,med);
+ if(acc<i) {
+ if(med==start) break;
+ start=med;
+ }
+ else {
+ if(end==0) break;
+ end = med-1;
+ }
+ }
+ acc = get_field(C_sampling,C_sampling_field_bits,start);
+ while(start<C_len-1 && acc+sample_rate*BLOCK_SIZE_LIGHT==get_field(C_sampling,C_sampling_field_bits,start+1)) {
+ start++;
+ acc +=sample_rate*BLOCK_SIZE_LIGHT;
+ }
+ acc = start*sample_rate*BLOCK_SIZE_LIGHT-acc;
+ pos = (start)*sample_rate;
+ uint pos_O = get_field(O_pos,O_pos_field_bits,start);
+ // Sequential search over C
+ uint s = 0;
+ for(;pos<C_len;pos++) {
+ s = get_field(C,C_field_bits,pos);
+ if(acc+BLOCK_SIZE_LIGHT-s>=i) break;
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,s);
+ acc += BLOCK_SIZE_LIGHT-s;
+ }
+ pos = (pos)*BLOCK_SIZE_LIGHT;
+ // Search inside the block
+
+ while(acc<i) {
+ uint new_posO = pos_O+E->get_log2binomial(BLOCK_SIZE_LIGHT,s);
+ uint block = E->short_bitmap(s,get_var_field(O,pos_O,new_posO-1));
+ pos_O = new_posO;
+ new_posO = 0;
+ while(acc<i && new_posO<BLOCK_SIZE_LIGHT) {
+ pos++;new_posO++;
+ acc += (((block&1)==0)?1:0);
+ block = block/2;
+ }
+ }
+ pos--;
+ assert(acc==i);
+ assert(rank0(pos)==i);
+ assert(!access(pos));
+ return pos;
+}
+
+uint static_bitsequence_rrr02_light::select1(uint i) {
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint C_sampling_len = C_len/sample_rate+2;
+ uint C_sampling_field_bits = bits(ones);
+ uint O_pos_field_bits = bits(O_bits_len);
+ if(i==0) return -1;
+ if(i>ones) return len;
+ // Search over partial sums
+ uint start=0;
+ uint end=C_sampling_len-1;
+ uint med, acc=0, pos;
+ while(start<end-1) {
+ med = (start+end)/2;
+ acc = get_field(C_sampling,C_sampling_field_bits,med);
+ if(acc<i) {
+ if(med==start) break;
+ start=med;
+ }
+ else {
+ if(end==0) break;
+ end = med-1;
+ }
+ }
+ acc = get_field(C_sampling,C_sampling_field_bits,start);
+ while(start<C_len-1 && acc==get_field(C_sampling,C_sampling_field_bits,start+1)) start++;
+ pos = (start)*sample_rate;
+ uint pos_O = get_field(O_pos,O_pos_field_bits,start);
+ acc = get_field(C_sampling,C_sampling_field_bits,start);
+ // Sequential search over C
+ uint s = 0;
+ for(;pos<C_len;pos++) {
+ s = get_field(C,C_field_bits,pos);
+ if(acc+s>=i) break;
+ pos_O += E->get_log2binomial(BLOCK_SIZE_LIGHT,s);
+ acc += s;
+ }
+ pos = (pos)*BLOCK_SIZE_LIGHT;
+ //cout << "pos=" << pos << endl;
+ // Search inside the block
+ while(acc<i) {
+ uint new_posO = pos_O+E->get_log2binomial(BLOCK_SIZE_LIGHT,s);
+ uint block = E->short_bitmap(s,get_var_field(O,pos_O,new_posO-1));
+ pos_O = new_posO;
+ new_posO = 0;
+ while(acc<i && new_posO<BLOCK_SIZE_LIGHT) {
+ pos++;new_posO++;
+ acc += (((block&1)!=0)?1:0);
+ block = block/2;
+ }
+ //cout << "i=" << i << " len=" << len << " ones=" << ones << " pos=" << pos << " acc=" << acc << " rank=" << rank1(pos) << endl;
+ }
+ pos--;
+ assert(acc==i);
+ assert(rank1(pos)==i);
+ assert(access(pos));
+ return pos;
+}
+
+uint static_bitsequence_rrr02_light::size() {
+ VARS_NEEDED
+ /*cout << "RRR02 SIZE: " << endl;
+ cout << "Default: " << 9*sizeof(uint)+sizeof(uint*)*4 << endl;
+ cout << "Cs: " << uint_len(C_len,C_field_bits)*sizeof(uint) << endl;
+ cout << "Os: " << O_len*sizeof(uint) << endl;
+ cout << "CSamp: " << uint_len(C_sampling_len,C_sampling_field_bits)*sizeof(uint) << endl;
+ cout << "OSamp: " << uint_len(O_pos_len,O_pos_field_bits)*sizeof(uint) << endl;
+ cout << "E: " << E->size() << endl;*/
+ uint sum = sizeof(uint)*8;//sizeof(static_bitsequence_rrr02_light);
+ sum += uint_len(C_len,C_field_bits)*sizeof(uint);
+ sum += O_len*sizeof(uint);
+ sum += uint_len(C_sampling_len,C_sampling_field_bits)*sizeof(uint);
+ sum += uint_len(O_pos_len,O_pos_field_bits)*sizeof(uint);
+ //sum += E->size();
+ return sum;
+}
+
+static_bitsequence_rrr02_light::~static_bitsequence_rrr02_light() {
+ if(C!=NULL) delete [] C;
+ if(O!=NULL) delete [] O;
+ if(C_sampling!=NULL) delete [] C_sampling;
+ if(O_pos!=NULL) delete [] O_pos;
+ E = E->unuse();
+}
+
+int static_bitsequence_rrr02_light::save(FILE * fp) {
+ uint C_len = len/BLOCK_SIZE_LIGHT + (len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint O_len = uint_len(1,O_bits_len);
+ uint wr = RRR02_LIGHT_HDR;
+ wr = fwrite(&wr,sizeof(uint),1,fp);
+ wr += fwrite(&len,sizeof(uint),1,fp);
+ wr += fwrite(&ones,sizeof(uint),1,fp);
+ wr += fwrite(&O_bits_len,sizeof(uint),1,fp);
+ wr += fwrite(&sample_rate,sizeof(uint),1,fp);
+ if(wr!=5) return -1;
+ wr = fwrite(C,sizeof(uint),uint_len(C_len,C_field_bits),fp);
+ if(wr!=uint_len(C_len,C_field_bits)) return -1;
+ wr = fwrite(O,sizeof(uint),O_len,fp);
+ if(wr!=O_len) return -1;
+ return 0;
+}
+
+static_bitsequence_rrr02_light * static_bitsequence_rrr02_light::load(FILE * fp) {
+ static_bitsequence_rrr02_light * ret = new static_bitsequence_rrr02_light();
+ uint rd = 0, type;
+ rd += fread(&type,sizeof(uint),1,fp);
+ rd += fread(&ret->len,sizeof(uint),1,fp);
+ rd += fread(&ret->ones,sizeof(uint),1,fp);
+ rd += fread(&ret->O_bits_len,sizeof(uint),1,fp);
+ rd += fread(&ret->sample_rate,sizeof(uint),1,fp);
+ uint C_len = ret->len/BLOCK_SIZE_LIGHT + (ret->len%BLOCK_SIZE_LIGHT!=0);
+ uint C_field_bits = bits(BLOCK_SIZE_LIGHT);
+ uint O_len = uint_len(1,ret->O_bits_len);
+ if(rd!=5 || type!=RRR02_LIGHT_HDR) {
+ delete ret;
+ return NULL;
+ }
+ ret->C = new uint[uint_len(C_len,C_field_bits)];
+ rd = fread(ret->C,sizeof(uint),uint_len(C_len,C_field_bits),fp);
+ if(rd!=uint_len(C_len,C_field_bits)) {
+ ret->C=NULL;
+ delete ret;
+ return NULL;
+ }
+ ret->O = new uint[O_len];
+ rd = fread(ret->O,sizeof(uint),O_len,fp);
+ if(rd!=O_len) {
+ ret->O=NULL;
+ delete ret;
+ return NULL;
+ }
+ ret->create_sampling(ret->sample_rate);
+ return ret;
+}
--- /dev/null
+/* static_bitsequence_rrr02_light.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * RRR02 Bitsequence - light version
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+
+#ifndef _STATIC_BITSEQUENCE_RRR02_LIGHT_H
+#define _STATIC_BITSEQUENCE_RRR02_LIGHT_H
+
+#define BLOCK_SIZE_LIGHT 15
+#define DEFAULT_SAMPLING_LIGHT 32
+
+#include <static_bitsequence.h>
+#include <table_offset.h>
+#include <cassert>
+#include <iostream>
+
+using namespace std;
+
+/** Implementation of Raman, Raman and Rao's [1] proposal for rank/select capable
+ * data structures, it achieves space nH_0, O(sample_rate) time for rank and O(log len)
+ * for select. The practial implementation is based on [2]
+ *
+ * [1] R. Raman, V. Raman and S. Rao. Succinct indexable dictionaries with applications
+ * to encoding $k$-ary trees and multisets. SODA02.
+ * [2] F. Claude and G. Navarro. Practical Rank/Select over Arbitrary Sequences. SPIRE08.
+ *
+ * @author Francisco Claude
+ */
+class static_bitsequence_rrr02_light: public static_bitsequence {
+public:
+ static_bitsequence_rrr02_light(uint * bitseq, uint len, uint sample_rate=DEFAULT_SAMPLING_LIGHT);
+ virtual ~static_bitsequence_rrr02_light();
+
+ /** Returns the number of zeros until position i */
+ virtual uint rank0(uint i);
+
+ /** Returns the number of ones until position i */
+ virtual uint rank1(uint i);
+
+ /** Returns the position of the i-th zero
+ * @return (uint)-1 if i=0, len if i>num_zeros or the position */
+ virtual uint select0(uint i);
+
+ /** Returns the position of the i-th one
+ * @return (uint)-1 if i=0, len if i>num_ones or the position */
+ virtual uint select1(uint i);
+
+ /** Returns the i-th bit */
+ virtual bool access(uint i);
+
+ /** Returns the size of the structure in bytes */
+ virtual uint size();
+
+ /** Stores the bitmap given a file pointer, return 0 in case of success */
+ virtual int save(FILE * fp);
+
+ /** Reads the bitmap from a file pointer, returns NULL in case of error */
+ static static_bitsequence_rrr02_light * load(FILE * fp);
+
+ /** Creates a new sampling for the queries */
+ void create_sampling(uint sampling_rate);
+
+ /** Frees the space required by the table E, which is static and global
+ * to all instances.
+ */
+ static void delete_E() {
+ delete E;
+ }
+
+protected:
+ static_bitsequence_rrr02_light();
+ /** Classes and offsets */
+ uint *C, *O;
+ uint O_bits_len;
+ /** C and O samplings */
+ uint *C_sampling, *O_pos;
+ /** Sample rate */
+ uint sample_rate;
+
+ static table_offset * E;
+};
+
+#endif /* _STATIC_BITSEQUENCE_RRR02_H */
--- /dev/null
+/* static_sequence_builder.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_BUILDER_H
+#define _STATIC_SEQUENCE_BUILDER_H
+
+#include <basics.h>
+#include <static_sequence.h>
+
+/** Base class for static sequence builders
+ * @author Francisco Claude
+ */
+class static_sequence_builder {
+ public:
+ virtual ~static_sequence_builder() {}
+ /** Returns a new sequence build for seq */
+ virtual static_sequence * build(uint * seq, uint len)=0;
+};
+
+#include <static_sequence_builder_wvtree.h>
+#include <static_sequence_builder_wvtree_noptrs.h>
+#include <static_sequence_builder_gmr.h>
+#include <static_sequence_builder_gmr_chunk.h>
+
+#endif
--- /dev/null
+/* static_sequence_builder_gmr.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder gmr
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_builder_gmr.h>
+
+static_sequence_builder_gmr::static_sequence_builder_gmr(uint chunk_length, static_bitsequence_builder *bmb, static_sequence_builder *ssb) {
+ this->chunk_length = chunk_length;
+ this->bmb = bmb;
+ this->ssb = ssb;
+}
+
+static_sequence * static_sequence_builder_gmr::build(uint * seq, uint len) {
+ return new static_sequence_gmr(seq,len,chunk_length,bmb,ssb);
+}
--- /dev/null
+/* static_sequence_builder_gmr.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder gmr
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_BUILDER_GMR_H
+#define _STATIC_SEQUENCE_BUILDER_GMR_H
+
+#include <basics.h>
+#include <static_sequence_gmr.h>
+#include <static_sequence_builder.h>
+
+/** gmr builder
+ * @author Francisco Claude
+ */
+class static_sequence_builder_gmr {
+ public:
+ static_sequence_builder_gmr(uint chunk_length, static_bitsequence_builder *bmb, static_sequence_builder *ssb);
+ virtual ~static_sequence_builder_gmr() {}
+ virtual static_sequence * build(uint * seq, uint len);
+
+ protected:
+ static_bitsequence_builder *bmb;
+ static_sequence_builder *ssb;
+ uint chunk_length;
+};
+
+#endif
--- /dev/null
+/* static_sequence_builder_gmr_chunk.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder gmr chunk
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_builder_gmr_chunk.h>
+
+static_sequence_builder_gmr_chunk::static_sequence_builder_gmr_chunk(static_bitsequence_builder *bmb, static_permutation_builder *pmb) {
+ this->bmb = bmb;
+ this->pmb = pmb;
+}
+
+static_sequence * static_sequence_builder_gmr_chunk::build(uint * seq, uint len) {
+ return new static_sequence_gmr_chunk(seq,len,bmb,pmb);
+}
--- /dev/null
+/* static_sequence_builder_gmr_chunk.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder gmr chunk
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_BUILDER_GMR_CHUNK_H
+#define _STATIC_SEQUENCE_BUILDER_GMR_CHUNK_H
+
+#include <basics.h>
+#include <static_sequence_gmr_chunk.h>
+#include <static_sequence_builder.h>
+#include <static_permutation_builder.h>
+
+/** gmr chunk builder
+ * @author Francisco Claude
+ */
+class static_sequence_builder_gmr_chunk : public static_sequence_builder {
+ public:
+ static_sequence_builder_gmr_chunk(static_bitsequence_builder *bmb, static_permutation_builder *pmb);
+ virtual ~static_sequence_builder_gmr_chunk() {}
+ virtual static_sequence * build(uint * seq, uint len);
+
+ protected:
+ static_bitsequence_builder *bmb;
+ static_permutation_builder *pmb;
+};
+
+#endif
--- /dev/null
+/* static_sequence_builder_wvtree.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder wavelet tree
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_builder_wvtree.h>
+
+static_sequence_builder_wvtree::static_sequence_builder_wvtree(wt_coder * wc, static_bitsequence_builder *bmb, alphabet_mapper * am) {
+ this->bmb = bmb;
+ this->wc = wc;
+ this->am = am;
+}
+
+static_sequence * static_sequence_builder_wvtree::build(uint * seq, uint len) {
+ return new static_sequence_wvtree(seq,len,wc,bmb,am);
+}
--- /dev/null
+/* static_sequence_builder_wvtree.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder wavelet tree
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_BUILDER_WVTREE_H
+#define _STATIC_SEQUENCE_BUILDER_WVTREE_H
+
+#include <basics.h>
+#include <wt_coder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence_wvtree.h>
+#include <static_sequence_builder.h>
+
+/** Builder for wavelet trees
+ * @author Francisco Claude
+ */
+class static_sequence_builder_wvtree : public static_sequence_builder {
+ public:
+ static_sequence_builder_wvtree(wt_coder * wc, static_bitsequence_builder *bmb, alphabet_mapper * am);
+ virtual ~static_sequence_builder_wvtree() {}
+ virtual static_sequence * build(uint * seq, uint len);
+
+ protected:
+ alphabet_mapper * am;
+ wt_coder * wc;
+ static_bitsequence_builder *bmb;
+};
+
+#endif
--- /dev/null
+/* static_sequence_builder_wvtree_noptrs.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder wavelet tree without pointers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_builder_wvtree_noptrs.h>
+
+static_sequence_builder_wvtree_noptrs::static_sequence_builder_wvtree_noptrs(static_bitsequence_builder *bmb, alphabet_mapper * am) {
+ this->bmb = bmb;
+ this->am = am;
+}
+
+static_sequence * static_sequence_builder_wvtree_noptrs::build(uint * seq, uint len) {
+ return new static_sequence_wvtree_noptrs(seq,len,bmb,am);
+}
--- /dev/null
+/* static_sequence_builder_wvtree_noptrs.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * Sequence builder wavelet tree without pointers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_BUILDER_WVTREE_NOPTRS_H
+#define _STATIC_SEQUENCE_BUILDER_WVTREE_NOPTRS_H
+
+#include <basics.h>
+#include <alphabet_mapper.h>
+#include <static_sequence_wvtree_noptrs.h>
+#include <static_sequence_builder.h>
+
+/** Builder for wavelet trees without pointers
+ * @author Francisco Claude
+ */
+class static_sequence_builder_wvtree_noptrs : public static_sequence_builder {
+ public:
+ static_sequence_builder_wvtree_noptrs(static_bitsequence_builder *bmb, alphabet_mapper * am);
+ virtual ~static_sequence_builder_wvtree_noptrs() {}
+ virtual static_sequence * build(uint * seq, uint len);
+
+ protected:
+ alphabet_mapper * am;
+ static_bitsequence_builder *bmb;
+};
+
+#endif
--- /dev/null
+/* static_sequence_gmr.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * GMR
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_gmr.h>
+
+static_sequence_gmr::static_sequence_gmr(uint * sequence, uint n, uint chunk_length, static_bitsequence_builder * bmb, static_sequence_builder * ssb) {
+ len = n;
+ if(len%chunk_length) len+=chunk_length-len%chunk_length;
+ uint * new_seq = new uint[len];
+ sigma = 0;
+ for(uint i=0;i<n;i++){
+ new_seq[i] = sequence[i];
+ sigma = max(sigma,new_seq[i]);
+ }
+ sigma++;
+ for(uint i=n;i<len;i++)
+ new_seq[i] = sigma;
+ if(len!=n) sigma++;
+ this->chunk_length = chunk_length;
+ build(new_seq,bmb,ssb);
+ delete [] new_seq;
+}
+
+static_sequence_gmr::static_sequence_gmr() {
+}
+
+static_sequence_gmr::~static_sequence_gmr() {
+ delete B;
+ for (uint i=0;i<len/chunk_length;i++)
+ delete chunk[i];
+ delete [] chunk;
+}
+
+
+void static_sequence_gmr::build(uint * sequence, static_bitsequence_builder * bmb, static_sequence_builder * ssb) {
+ uint num_chunks = len/chunk_length;
+ chunk = new static_sequence*[num_chunks];
+ assert(chunk!=NULL);
+ for (uint i=0;i<num_chunks;i++) {
+ chunk[i] = ssb->build(sequence+i*chunk_length, chunk_length);
+ //cout << "1." << i << endl; cout.flush();
+ assert(chunk[i]!=NULL);
+ }
+ uint * ones = get_ones(sequence);
+ uint *B_bitmap = new uint[(2+len+(unsigned long long)num_chunks*sigma)/W+1];
+ assert(B_bitmap!=NULL);
+ for (uint i=0;i<(2+len+(unsigned long long)num_chunks*sigma)/W+1;i++)
+ B_bitmap[i] = 0;
+ uint pos=0;
+ for (unsigned long long i=0;i<(unsigned long long)num_chunks*sigma;i++) {
+ for (uint j=0;j<ones[i];j++) {
+ bitset(B_bitmap, pos);
+ pos++;
+ }
+ pos++;
+ }
+ pos++;
+ //cout << "5 pos=" << pos << endl; cout.flush();
+ B = bmb->build(B_bitmap, pos);
+ //cout << "6" << endl; cout.flush();
+ delete [] B_bitmap;
+ delete [] ones;
+}
+
+
+uint * static_sequence_gmr::get_ones(uint * sequence) {
+ uint * ones = new uint[(unsigned long long)(len/chunk_length)*sigma];
+ assert(ones!=NULL);
+ for (uint i=0;i<(unsigned long long)(len/chunk_length)*sigma;i++) ones[i] = 0;
+ for (uint i=0;i<len;i++) {
+ uint whichChunk = (uint)(((unsigned long long)sequence[i]*len+i)/chunk_length);
+ ones[whichChunk]++;
+ }
+ return ones;
+}
+
+
+uint static_sequence_gmr::rank(uint c, uint j) {
+// c++;
+ uint i = j/chunk_length;
+ uint bp = (c)*(len/chunk_length);
+ uint rank_pos = B->select0(bp);
+ uint prev = rank_pos-bp+1;
+ uint sum = B->rank1(B->select0(bp+i)) - prev;
+ uint cr = chunk[i]->rank(c,j-i*chunk_length);
+ return sum + cr;
+}
+
+
+uint static_sequence_gmr::select(uint c, uint j) {
+// c++;
+ uint rank_pos = B->select0(c*(len/chunk_length));
+ uint prev = B->rank1(rank_pos);
+ uint sel = prev+j;
+ uint block = (B->select1(sel));
+ uint i = block-sel+1;
+ uint desp = B->rank1(B->select0((i)))-prev;
+ if (desp+1==0) desp=0;
+ uint rchunk = i%(len/chunk_length);
+ return (rchunk*chunk_length)+chunk[rchunk]->select(c, j-desp);
+}
+
+
+uint static_sequence_gmr::access(uint j) {
+ return chunk[j/chunk_length]->access(j%chunk_length);
+}
+
+
+uint static_sequence_gmr::size() {
+ uint s = 0;
+ for (uint i=0;i<len/chunk_length;i++)
+ s += sizeof(void*)+chunk[i]->size();
+ return s+B->size()+sizeof(static_sequence_gmr);
+}
+
+uint static_sequence_gmr::save(FILE *fp) {
+ uint wr = GMR_HDR;
+ wr = fwrite(&wr,sizeof(uint),1,fp);
+ wr += fwrite(&len,sizeof(uint),1,fp);
+ wr += fwrite(&sigma,sizeof(uint),1,fp);
+ wr += fwrite(&chunk_length,sizeof(uint),1,fp);
+ if(wr!=4) return 1;
+ if(B->save(fp)) return 1;
+ for(uint i=0;i<len/chunk_length;i++)
+ if(chunk[i]->save(fp)) return 1;
+ return 0;
+}
+
+static_sequence_gmr * static_sequence_gmr::load(FILE *fp) {
+ uint rd;
+ if(fread(&rd,sizeof(uint),1,fp)!=1) return NULL;
+ if(rd!=GMR_HDR) return NULL;
+ static_sequence_gmr * ret = new static_sequence_gmr();
+ rd = fread(&ret->len,sizeof(uint),1,fp);
+ rd += fread(&ret->sigma,sizeof(uint),1,fp);
+ rd += fread(&ret->chunk_length,sizeof(uint),1,fp);
+ if(rd!=3) {
+ delete ret;
+ return NULL;
+ }
+ ret->B = static_bitsequence::load(fp);
+ if(ret->B==NULL) {
+ delete ret;
+ return NULL;
+ }
+ ret->chunk = new static_sequence*[ret->len/ret->chunk_length];
+ for(uint i=0;i<ret->len/ret->chunk_length;i++) {
+ ret->chunk[i] = static_sequence::load(fp);
+ if(ret->chunk[i]==NULL) {
+ delete ret;
+ return NULL;
+ }
+ }
+ return ret;
+}
--- /dev/null
+/* static_sequence_gmr.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * GMR
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_GMR_H
+#define _STATIC_SEQUENCE_GMR_H
+
+#include <basics.h>
+#include <static_sequence.h>
+#include <static_bitsequence.h>
+#include <static_sequence_builder.h>
+#include <static_bitsequence_builder.h>
+#include <cassert>
+#include <iostream>
+
+using namespace std;
+
+class static_sequence_gmr : public static_sequence {
+ public:
+ static_sequence_gmr(uint * sequence, uint n, uint chunk_length, static_bitsequence_builder * bmb, static_sequence_builder * ssb);
+ ~static_sequence_gmr();
+ virtual uint rank(uint c, uint j);
+ virtual uint select(uint c, uint j);
+ virtual uint access(uint j);
+ virtual uint size();
+ virtual uint save(FILE *fp);
+ static static_sequence_gmr * load(FILE *fp);
+
+ protected:
+ static_sequence_gmr();
+ void build(uint * sequence, static_bitsequence_builder * bmb, static_sequence_builder * ssb);
+ uint * get_ones(uint * sequence);
+
+ uint sigma, chunk_length;
+ static_sequence ** chunk;
+ static_bitsequence * B;
+};
+
+#endif
--- /dev/null
+/* static_sequence_wvtree_noptrs.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_wvtree_noptrs definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <static_sequence_wvtree_noptrs.h>
+
+static_sequence_wvtree_noptrs::static_sequence_wvtree_noptrs(uint * symbols, uint n, static_bitsequence_builder * bmb, alphabet_mapper * am) {
+ this->n=n;
+ this->am=am;
+ am->use();
+ for(uint i=0;i<n;i++)
+ symbols[i] = am->map(symbols[i]);
+ max_v=max_value(symbols,n);
+ height=bits(max_v);
+ uint *occurrences=new uint[max_v+1];
+ for(uint i=0;i<=max_v;i++) occurrences[i]=0;
+ for(uint i=0;i<n;i++)
+ occurrences[symbols[i]]++;
+ uint to_add=0;
+ for(uint i=0;i<max_v;i++)
+ if(occurrences[i]==0) to_add++;
+ uint * new_symb = new uint[n+to_add];
+ for(uint i=0;i<n;i++)
+ new_symb[i] = symbols[i];
+ to_add = 0;
+ for(uint i=0;i<max_v;i++)
+ if(occurrences[i]==0) {
+ occurrences[i]++;
+ new_symb[n+to_add]=i;
+ to_add++;
+ }
+ uint new_n = n+to_add;
+ for(uint i=1;i<=max_v;i++)
+ occurrences[i] += occurrences[i-1];
+ uint *oc = new uint[(new_n+1)/W+1];
+ for(uint i=0;i<(new_n+1)/W+1;i++)
+ oc[i] = 0;
+ for(uint i=0;i<=max_v;i++)
+ bitset(oc,occurrences[i]-1);
+ bitset(oc,new_n);
+ occ = bmb->build(oc,new_n+1);
+ delete [] occurrences;
+ this->n = new_n;
+ uint ** _bm=new uint*[height];
+ for(uint i=0;i<height;i++) {
+ _bm[i] = new uint[new_n/W+1];
+ for(uint j=0;j<new_n/W+1;j++)
+ _bm[i][j]=0;
+ }
+ build_level(_bm,new_symb,0,new_n,0);
+ bitstring = new static_bitsequence*[height];
+ for(uint i=0;i<height;i++) {
+ bitstring[i] = bmb->build(_bm[i],new_n);
+ delete [] _bm[i];
+ }
+ delete [] _bm;
+ for(uint i=0;i<n;i++)
+ symbols[i] = am->unmap(symbols[i]);
+ delete [] new_symb;
+ delete [] oc;
+}
+
+static_sequence_wvtree_noptrs::static_sequence_wvtree_noptrs() {
+}
+
+static_sequence_wvtree_noptrs::~static_sequence_wvtree_noptrs() {
+ for(uint i=0;i<height;i++)
+ delete bitstring[i];
+ delete [] bitstring;
+ delete occ;
+ am->unuse();
+}
+
+uint static_sequence_wvtree_noptrs::save(FILE *fp) {
+ uint wr = WVTREE_NOPTRS_HDR;
+ wr = fwrite(&wr,sizeof(uint),1,fp);
+ wr += fwrite(&n,sizeof(uint),1,fp);
+ wr += fwrite(&max_v,sizeof(uint),1,fp);
+ wr += fwrite(&height,sizeof(uint),1,fp);
+ if(wr!=4) return 1;
+ if(am->save(fp)) return 1;
+ for(uint i=0;i<height;i++)
+ if(bitstring[i]->save(fp)) return 1;
+ if(occ->save(fp)) return 1;
+ return 0;
+}
+
+static_sequence_wvtree_noptrs * static_sequence_wvtree_noptrs::load(FILE *fp) {
+ uint rd;
+ if(fread(&rd,sizeof(uint),1,fp)!=1) return NULL;
+ if(rd!=WVTREE_NOPTRS_HDR) return NULL;
+ static_sequence_wvtree_noptrs * ret = new static_sequence_wvtree_noptrs();
+ rd = fread(&ret->n,sizeof(uint),1,fp);
+ rd += fread(&ret->max_v,sizeof(uint),1,fp);
+ rd += fread(&ret->height,sizeof(uint),1,fp);
+ if(rd!=3) {
+ delete ret;
+ return NULL;
+ }
+ ret->am = alphabet_mapper::load(fp);
+ if(ret->am==NULL) {
+ delete ret;
+ return NULL;
+ }
+ ret->am->use();
+ ret->bitstring = new static_bitsequence*[ret->height];
+ for(uint i=0;i<ret->height;i++) {
+ ret->bitstring[i] = static_bitsequence::load(fp);
+ if(ret->bitstring[i]==NULL){
+ delete ret;
+ return NULL;
+ }
+ }
+ ret->occ = static_bitsequence::load(fp);
+ if(ret->occ==NULL) {
+ delete ret;
+ return NULL;
+ }
+ return ret;
+}
+
+uint static_sequence_wvtree_noptrs::access(uint pos) {
+ uint level=0;
+ uint ret=0;
+ uint start=0;
+ uint end=n-1;
+ while(level<height) {
+ assert(pos>=start && pos<=end);
+ if(bitstring[level]->access(pos)) {
+ ret=set(ret,level);
+ pos=bitstring[level]->rank1(pos-1)-bitstring[level]->rank1(start-1);
+ start=(bitstring[level]->rank1(end)-bitstring[level]->rank1(start-1));
+ start=end-start+1;
+ pos+=start;
+ }
+ else {
+ pos=pos-start-(bitstring[level]->rank1(pos)-bitstring[level]->rank1(start-1));
+ end=end-start-(bitstring[level]->rank1(end)-bitstring[level]->rank1(start-1));
+ end+=start;
+ pos+=start;
+ }
+ level++;
+ }
+ return am->unmap(ret);
+}
+
+uint static_sequence_wvtree_noptrs::rank(uint symbol, uint pos) {
+ symbol = am->map(symbol);
+ uint level=0;
+ uint start=0;
+ uint end=n-1;
+ uint count=0;
+ while(level<height) {
+ if(is_set(symbol,level)) {
+ pos=bitstring[level]->rank1(pos)-bitstring[level]->rank1(start-1)-1;
+ count=pos+1;
+ start=(bitstring[level]->rank1(end)-bitstring[level]->rank1(start-1));
+ start=end-start+1;
+ pos+=start;
+ }
+ else {
+ pos=pos-start+bitstring[level]->rank1(start-1)-bitstring[level]->rank1(pos);
+ count=pos+1;
+ end=end-start-(bitstring[level]->rank1(end)-bitstring[level]->rank1(start-1));
+ end+=start;
+ pos+=start;
+ }
+ level++;
+ if(count==0) return 0;
+ }
+ return count;
+}
+
+inline uint get_start(uint symbol, uint mask) {
+ return symbol&mask;
+}
+
+inline uint get_end(uint symbol, uint mask) {
+ return get_start(symbol,mask)+!mask+1;
+}
+
+uint static_sequence_wvtree_noptrs::select(uint symbol, uint j) {
+ symbol = am->map(symbol);
+ uint mask = (1<<height)-2;
+ uint sum=2;
+ uint level = height-1;
+ uint pos=j;
+ while(true) {
+ uint start = get_start(symbol,mask);
+ uint end = min(max_v+1,start+sum);
+ start = (start==0)?0:(occ->select1(start)+1);
+ end = occ->select1(end+1)-1;
+ if(is_set(symbol,level)) {
+ uint ones_start = bitstring[level]->rank1(start-1);
+ pos = bitstring[level]->select1(ones_start+pos)-start+1;
+ }
+ else {
+ uint ones_start = bitstring[level]->rank1(start-1);
+ pos = bitstring[level]->select0(start-ones_start+pos)-start+1;
+ }
+ mask <<=1;
+ sum <<=1;
+ if(level==0) break;
+ level--;
+ }
+ return pos-1;
+}
+
+uint static_sequence_wvtree_noptrs::size() {
+ uint ptrs = sizeof(static_sequence_wvtree_noptrs)+height*sizeof(static_sequence*);
+ uint bytesBitstrings = 0;
+ for(uint i=0;i<height;i++)
+ bytesBitstrings += bitstring[i]->size();
+ return bytesBitstrings+occ->size()+ptrs;
+}
+
+void static_sequence_wvtree_noptrs::build_level(uint **bm, uint *symbols, uint level, uint length, uint offset) {
+ if(level==height) return;
+ uint cleft=0;
+ for(uint i=0;i<length;i++)
+ if(!is_set(symbols[i],level))
+ cleft++;
+ uint cright=length-cleft;
+ uint *left=new uint[cleft], *right=new uint[cright];
+ cleft=cright=0;
+ for(uint i=0;i<length;i++)
+ if(!is_set(symbols[i],level)) {
+ left[cleft++]=symbols[i];
+ bitclean(bm[level],offset+i);
+ }
+ else {
+ right[cright++]=symbols[i];
+ bitset(bm[level],offset+i);
+ }
+ build_level(bm,left,level+1,cleft,offset);
+ build_level(bm,right,level+1,cright,offset+cleft);
+ delete [] left;
+ delete [] right;
+}
+
+uint static_sequence_wvtree_noptrs::max_value(uint *symbols, uint n) {
+ uint max_v = 0;
+ for(uint i=0;i<n;i++)
+ max_v = max(symbols[i],max_v);
+ return max_v;
+}
+
+uint static_sequence_wvtree_noptrs::bits(uint val) {
+ uint ret = 0;
+ while(val!=0) {
+ ret++;
+ val >>= 1;
+ }
+ return ret;
+}
+
+bool static_sequence_wvtree_noptrs::is_set(uint val, uint ind) {
+ assert(ind<height);
+ return (val & (1<<(height-ind-1)))!=0;
+}
+
+
+uint static_sequence_wvtree_noptrs::set(uint val, uint ind) {
+ assert(ind<=height);
+ return val | (1<<(height-ind-1));
+}
--- /dev/null
+/* static_sequence_wvtree_noptrs.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_wvtree_noptrs definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _STATIC_SEQUENCE_WVTREE_NOPTRS_H
+#define _STATIC_SEQUENCE_WVTREE_NOPTRS_H
+
+#include <iostream>
+#include <cassert>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <static_sequence.h>
+#include <alphabet_mapper.h>
+
+using namespace std;
+
+class static_sequence_wvtree_noptrs : public static_sequence {
+ public:
+
+ /** Builds a Wavelet Tree for the string
+ * pointed by symbols assuming its length
+ * equals n and uses bmb to build the bitsequence */
+ static_sequence_wvtree_noptrs(uint * symbols, uint n, static_bitsequence_builder * bmb, alphabet_mapper * am);
+
+ /** Destroys the Wavelet Tree */
+ virtual ~static_sequence_wvtree_noptrs();
+
+ virtual uint rank(uint symbol, uint pos);
+ virtual uint select(uint symbol, uint i);
+ virtual uint access(uint pos);
+ virtual uint size();
+
+ virtual uint save(FILE *fp);
+ static static_sequence_wvtree_noptrs * load(FILE *fp);
+
+ protected:
+
+ static_sequence_wvtree_noptrs();
+
+ alphabet_mapper * am;
+ /** Only one bit-string for the Wavelet Tree. */
+ static_bitsequence **bitstring, *occ;
+
+ /** Length of the string. */
+ uint n;
+
+ /** Height of the Wavelet Tree. */
+ uint height,max_v;
+
+ /** Obtains the maximum value from the string
+ * symbols of length n */
+ uint max_value(uint * symbols, uint n);
+
+ /** How many bits are needed to represent val */
+ uint bits(uint val);
+
+ /** Returns true if val has its ind-th bit set
+ * to one. */
+ bool is_set(uint val, uint ind);
+
+ /** Sets the ind-th bit in val */
+ uint set(uint val, uint ind);
+
+ /** Recursive function for building the Wavelet Tree. */
+ void build_level(uint **bm, uint *symbols, uint level, uint length, uint offset);
+};
+#endif
--- /dev/null
+/* alphabet_mapper_cont.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * alphabet_mapper_cont definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <alphabet_mapper_cont.h>
+
+alphabet_mapper_cont::alphabet_mapper_cont(uint * seq, uint n, static_bitsequence_builder *bmb) {
+ uint max_v = 0;
+ for(uint i=0;i<n;i++)
+ max_v = max(max_v,seq[i]);
+ max_v++;
+ uint blen = uint_len(max_v,1);
+ uint * bmap = new uint[blen];
+ for(uint i=0;i<blen;i++)
+ bmap[i] = 0;
+ for(uint i=0;i<n;i++)
+ bitset(bmap,seq[i]);
+ m = bmb->build(bmap,max_v);
+ delete [] bmap;
+}
+
+alphabet_mapper_cont::alphabet_mapper_cont() {
+}
+
+alphabet_mapper_cont::~alphabet_mapper_cont() {
+ delete m;
+}
+
+uint alphabet_mapper_cont::map(uint s) {
+ return m->rank1(s);
+}
+
+uint alphabet_mapper_cont::unmap(uint s) {
+ return m->select1(s);
+}
+
+uint alphabet_mapper_cont::size() {
+ return sizeof(alphabet_mapper_cont)+m->size();
+}
+
+uint alphabet_mapper_cont::save(FILE *fp) {
+ uint wr = ALPHABET_MAPPER_CONT_HDR;
+ wr = fwrite(&wr,sizeof(uint),1,fp);
+ if(wr!=1) return 1;
+ if(m->save(fp)) return 1;
+ return 0;
+}
+
+alphabet_mapper_cont * alphabet_mapper_cont::load(FILE * fp) {
+ uint rd;
+ if(fread(&rd,sizeof(uint),1,fp)!=1) return NULL;
+ if(rd!=ALPHABET_MAPPER_CONT_HDR) return NULL;
+ alphabet_mapper_cont * ret = new alphabet_mapper_cont();
+ ret->m = static_bitsequence::load(fp);
+ if(ret->m==NULL) {
+ delete ret;
+ return NULL;
+ }
+ return ret;
+}
--- /dev/null
+/* alphabet_mapper_cont.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * alphabet_mapper_cont definition
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef _ALPHABET_MAPPER_CONT_H
+#define _ALPHABET_MAPPER_CONT_H
+
+#include <basics.h>
+#include <iostream>
+#include <alphabet_mapper.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+
+using namespace std;
+
+/** Mapper that doesn't change the value (identity)
+ *
+ * @author Francisco Claude
+ */
+class alphabet_mapper_cont : public alphabet_mapper {
+ public:
+ alphabet_mapper_cont(uint * seq, uint n, static_bitsequence_builder *bmb);
+ virtual ~alphabet_mapper_cont();
+ virtual uint map(uint s);
+ virtual uint unmap(uint s);
+ virtual uint size();
+ virtual uint save(FILE *fp);
+ static alphabet_mapper_cont * load(FILE *fp);
+
+ protected:
+ alphabet_mapper_cont();
+ static_bitsequence * m;
+};
+
+#endif /* _ALPHABET_MAPPER_CONT_H */
--- /dev/null
+/* static_bitsequence_test.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_test
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include "static_bitsequence_tester.h"
+
+using namespace std;
+
+int main(int argc, char ** argv) {
+ if(argc!=5) {
+ cout << "usage: " << argv[0] << " <bitmap_file> <b|r> <sample_rate> <t|s>" << endl;
+ return 0;
+ }
+ FILE * fp = fopen(argv[1],"r");
+ if(fp==NULL) {
+ cout << "Error opening " << argv[1] << endl;
+ return -1;
+ }
+ uint *bitseq, len;//, ones;
+ uint l=fread(&len, sizeof(uint), 1, fp);
+ //l += fread(&ones,sizeof(uint),1,fp);
+ bitseq = new uint[uint_len(len,1)];
+ l+=fread(bitseq, sizeof(uint), uint_len(len,1), fp);
+ fclose(fp);
+
+ uint sample_rate;
+ stringstream ss(argv[3]);
+ ss >> sample_rate;
+
+ static_bitsequence * bs;
+
+ if(string(argv[2])==string("r")) bs = new static_bitsequence_rrr02(bitseq,len,sample_rate);
+ else bs = new static_bitsequence_brw32(bitseq,len,sample_rate);
+
+ cout << "Size: " << bs->size() << endl;
+ cout << "bpb = " << bs->size()*8./len << endl;
+
+ if(string(argv[4])==string("t"))
+ test_bitsequence(bitseq,len,bs);
+ cout << "******************************************" << endl;
+ speed_access(bs, bitseq, len);
+ cout << "******************************************" << endl;
+ speed_rank0(bs, bitseq, len);
+ cout << "******************************************" << endl;
+ speed_rank1(bs, bitseq, len);
+ cout << "******************************************" << endl;
+ speed_select0(bs, bitseq, len);
+ cout << "******************************************" << endl;
+ speed_select1(bs, bitseq, len);
+}
--- /dev/null
+/* static_bitsequence_tester.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_tester
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+
+using namespace std;
+
+/* Time meassuring */
+double ticks= (double)sysconf(_SC_CLK_TCK);
+struct tms t1,t2;
+
+void start_clock() {
+ times (&t1);
+}
+
+
+double stop_clock() {
+ times (&t2);
+ return (t2.tms_utime-t1.tms_utime)/ticks;
+}
+/* end Time meassuring */
+
+uint NQUERIES=10000000;
+uint SEED=47;
+
+void load(char *fname, uint ** text, uint * n) {
+ FILE * fp = fopen(fname,"r");
+ if(fp==NULL) {
+ cout << "could not open " << fname << endl;
+ return;
+ }
+ if(fread(n,sizeof(uint),1,fp)!=1) {
+ cout << "Error reading file " << fname << endl;
+ return;
+ }
+ *text = new uint[uint_len(*n,1)];
+
+ if(fread(*text,sizeof(uint),uint_len(*n,1),fp)!=uint_len(*n,1)) {
+ cout << "Error reading file " << fname << endl;
+ return;
+ }
+}
+
+void test_bitsequence(uint * bitseq, uint len, static_bitsequence * bs) {
+ uint ones = 0;
+ bool error = false;
+ for(uint i=0;i<len && !error;i++) {
+ //cout << "i="<<i<< endl;
+ if(i>0) {
+ if(i%max(1,(bs->length()/100))==0) { cout << "."; cout.flush(); }
+ if(i%max(1,(bs->length()/10))==0) { cout << endl; cout.flush(); }
+ }
+ if(bitget(bitseq,i)) ones++;
+ if(bs->access(i) != (bitget(bitseq,i)!=0)) {
+ cout << "Access error for position " << i << endl;
+ cout << " got: " << bs->access(i) << " expected: " << (bitget(bitseq,i)!=0) << endl;
+ error = true;
+ }
+ if(bs->rank1(i) != ones) {
+ cout << "Rank1 error for position " << i << endl;
+ cout << " got: " << bs->rank1(i) << " expected: " << ones << endl;
+ error = true;
+ }
+ if(bitget(bitseq,i) && bs->select1(ones) != i) {
+ cout << "Select1 error for position " << i << " ones:" << ones << endl;
+ cout << " got: " << bs->select1(ones) << " expected: " << i << endl;
+ error = true;
+ }
+ if(bs->rank0(i) != i+1-ones) {
+ cout << "Rank0 error for position " << i << endl;
+ cout << " got: " << bs->rank0(i) << " expected: " << ones << endl;
+ error = true;
+ }
+ if(!bitget(bitseq,i) && bs->select0(i+1-ones) != i) {
+ cout << "Select0 error for position " << i << endl;
+ cout << " got: " << bs->select0(i+1-ones) << " expected: " << i << endl;
+ error = true;
+ }
+ }
+ cout << "." << endl;
+}
+
+void speed_access(static_bitsequence * ss, uint * bitseq, uint n) {
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%n;
+ acc += ss->access(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " accesses: " << t << " secs" << endl;
+ cout << " * Time per access: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
+
+void speed_rank0(static_bitsequence * ss, uint * bitseq, uint n) {
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%n;
+ acc += ss->rank0(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " rank0s: " << t << " secs" << endl;
+ cout << " * Time per rank0: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
+
+void speed_rank1(static_bitsequence * ss, uint * bitseq, uint n) {
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%n;
+ acc += ss->rank1(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " rank1s: " << t << " secs" << endl;
+ cout << " * Time per rank1: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
+
+void speed_select0(static_bitsequence * ss, uint * bitseq, uint n) {
+ uint acc=0;
+ uint ones=ss->rank0(n-1);
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%ones+1;
+ acc += ss->select0(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " select0s: " << t << " secs" << endl;
+ cout << " * Time per select0: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
+
+void speed_select1(static_bitsequence * ss, uint * bitseq, uint n) {
+ uint acc=0;
+ uint ones=ss->rank1(n-1);
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%ones+1;
+ acc += ss->select1(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " select1s: " << t << " secs" << endl;
+ cout << " * Time per select1: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
--- /dev/null
+/* static_bitsequence_tester.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_bitsequence_tester
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+
+
+#ifndef STATIC_BITSEQUENCE_TESTER_H
+#define STATIC_BITSEQUENCE_TESTER_H
+
+void load(char *fname, uint ** text, uint * n);
+void test_bitsequence(uint * bitseq, uint len, static_bitsequence * bs);
+void speed_access(static_bitsequence * ss, uint * bitseq, uint n);
+void speed_rank0(static_bitsequence * ss, uint * bitseq, uint n);
+void speed_rank1(static_bitsequence * ss, uint * bitseq, uint n);
+void speed_select0(static_bitsequence * ss, uint * bitseq, uint n);
+void speed_select1(static_bitsequence * ss, uint * bitseq, uint n);
+
+#endif
--- /dev/null
+/* static_sequence_gmr_chunk_test.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_gmr_chunk_test
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+#include "static_sequence_tester.h"
+
+int main(int argc, char ** argv) {
+ if(argc!=6) {
+ cout << "Usage: " << argv[0] << " <file> <b|r> <sampling> <perm_samp> <t|s>" << endl;
+ return 0;
+ }
+ stringstream ss;
+ ss << argv[3];
+ uint samp;
+ ss >> samp;
+ stringstream ss2;
+ ss2 << argv[4];
+ uint perm_samp;
+ ss2 >> perm_samp;
+
+ uint * text;
+ uint n;
+ load(argv[1],&text,&n);
+
+ static_bitsequence_builder * bmb;
+ if(string(argv[2])==string("b"))
+ bmb = new static_bitsequence_builder_brw32(samp);
+ else
+ bmb = new static_bitsequence_builder_rrr02(samp);
+
+ static_permutation_builder * spb = new static_permutation_builder_mrrr(perm_samp,bmb);
+ static_sequence_builder * ssb = new static_sequence_builder_gmr_chunk(bmb, spb);
+ static_sequence * sseq = ssb->build(text,n);
+
+ delete bmb;
+ delete ssb;
+ delete spb;
+
+ sseq = savetest(argv[1], sseq);
+ if(string(argv[5])==string("t"))
+ test_static_sequence(text,n,sseq);
+ else
+ cout << "Size: " << sseq->size() << endl;
+ cout << "*************************************" << endl;
+ speed_access(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_rank(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_select(sseq,text,n);
+
+ delete sseq;
+ delete [] text;
+}
+
--- /dev/null
+/* static_sequence_gmr_test.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_gmr_test
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <wt_coder.h>
+#include <static_sequence_builder.h>
+#include "static_sequence_tester.h"
+
+int main(int argc, char ** argv) {
+ if(argc!=8) {
+ cout << "Usage: " << argv[0] << " <file> <b|r> <p|w|c> <sampling> <chunk_length> <perm_samp> <t|s>" << endl;
+ return 0;
+ }
+ stringstream ss;
+ ss << argv[4];
+ uint samp;
+ ss >> samp;
+ stringstream ss2;
+ ss2 << argv[5];
+ uint chunk_length;
+ ss2 >> chunk_length;
+ stringstream ss3;
+ ss3 << argv[6];
+ uint perm_samp;
+ ss3 >> perm_samp;
+
+ uint * text;
+ uint n;
+ load(argv[1],&text,&n);
+
+ static_bitsequence_builder * bmb;
+ if(string(argv[2])==string("b"))
+ bmb = new static_bitsequence_builder_brw32(samp);
+ else
+ bmb = new static_bitsequence_builder_rrr02(samp);
+
+ static_sequence_builder * ssb;
+
+ if(string(argv[3])==string("w")) {
+ alphabet_mapper * am = new alphabet_mapper_cont(text,n,bmb);
+ ssb = new static_sequence_builder_wvtree_noptrs(bmb,am);
+ } else if(string(argv[3])==string("p")) {
+ alphabet_mapper * am = new alphabet_mapper_none();
+ wt_coder * wc = new wt_coder_huff(text,n,am);
+ ssb = new static_sequence_builder_wvtree(wc,bmb,am);
+ } else {
+ ssb = new static_sequence_builder_gmr_chunk(bmb, new static_permutation_builder_mrrr(perm_samp,bmb));
+ }
+
+ static_sequence * sseq = new static_sequence_gmr(text,n,chunk_length,bmb,ssb);
+
+ delete bmb;
+ delete ssb;
+
+ sseq = savetest(argv[1], sseq);
+ if(string(argv[7])==string("t"))
+ test_static_sequence(text,n,sseq);
+ else
+ cout << "Size: " << sseq->size() << endl;
+ cout << "*************************************" << endl;
+ speed_access(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_rank(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_select(sseq,text,n);
+
+ delete sseq;
+ delete [] text;
+}
+
--- /dev/null
+/* static_sequence_tester.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_tester
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include "static_sequence_tester.h"
+
+using namespace std;
+
+/* Time meassuring */
+double ticks= (double)sysconf(_SC_CLK_TCK);
+struct tms t1,t2;
+
+void start_clock() {
+ times (&t1);
+}
+
+
+double stop_clock() {
+ times (&t2);
+ return (t2.tms_utime-t1.tms_utime)/ticks;
+}
+/* end Time meassuring */
+
+uint NQUERIES=100000;
+uint SEED=47;
+
+void test_static_sequence(uint * symbols, uint n, static_sequence * ss) {
+ cout << "Size: " << ss->size() << endl;
+ uint max_v=0;
+ for(uint i=0;i<n;i++)
+ max_v = max(max_v,symbols[i]);
+ uint * occ = new uint[max_v+1];
+ for(uint i=0;i<=max_v;i++)
+ occ[i] = 0;
+ bool error = false;
+ for(uint i=0;i<n && !error;i++) {
+ if(i!=0 && i%max(1,(n-1)/100)==0) { cout << "."; cout.flush(); }
+ if(i!=0 && i%max(1,(n-1)/10)==0) cout << endl;
+ occ[symbols[i]]++;
+ uint a = /*symbols[i]; /*/ss->access(i);
+ uint r = /*occ[symbols[i]];/*/ss->rank(symbols[i],i);
+ uint s = /*i; /*/ss->select(symbols[i],occ[symbols[i]]);
+ uint rM1 = (i==0)?0:ss->rank(symbols[i],i-1);
+ if(r!=occ[symbols[i]]) {
+ cout << "Error in rank for symbol " << symbols[i] << " at position " << i << endl;
+ cout << "value: " << r << endl;
+ cout << "Expected: " << occ[symbols[i]] << endl;
+ error = true;
+ }
+ if(s!=i) {
+ cout << "Error in select for symbol " << symbols[i] << " at position " << occ[symbols[i]] << endl;
+ cout << "value: " << s << endl;
+ cout << "Expected: " << i << endl;
+ error = true;
+ }
+ if(a!=symbols[i]) {
+ cout << "Error in access at position " << i << endl;
+ cout << "value: " << a << endl;
+ cout << "Expected: " << symbols[i] << endl;
+ error = true;
+ }
+ if(rM1!=occ[symbols[i]]-1) {
+ cout << "Error in rankM1 for symbol " << symbols[i] << " at position " << i-1 << endl;
+ cout << "value: " << rM1 << endl;
+ cout << "Expected: " << occ[symbols[i]]-1 << endl;
+ error = true;
+ }
+ }
+ if(!error)
+ cout << "Test OK! It works :)" << endl;
+ delete [] occ;
+}
+
+void load(char *fname, uint ** text, uint * n) {
+ struct stat text_info;
+ if(stat(fname,&text_info)<0) {
+ cout << "could not stat: " << fname << endl;
+ return;
+ }
+
+ *n= (uint)text_info.st_size/4;
+ *text = new uint[*n+1];
+ FILE * fp = fopen(fname,"r");
+ if(fp==NULL) {
+ cout << "could not open " << fname << endl;
+ return;
+ }
+
+ cout << "File: " << fname << endl;
+ cout << "Length: " << *n << endl;
+
+ uint max_symbol = 0;
+ for(uint i=0;i<*n;i++) {
+ uint c;
+ uint read=fread(&c,sizeof(uint),1,fp);
+ //assert(read==1);
+ (*text)[i] = 1+(uint)c;
+ c += read;
+ max_symbol = max(max_symbol,(*text)[i]);
+ }
+ max_symbol++;
+ fclose(fp);
+
+ /*static_sequence * ss = ssb->build(*text,*n);
+
+ char * fname2 = new char[10+string(fname).length()];
+ sprintf(fname2,"%s.wt",fname);
+ fp = fopen(fname2,"w");
+ ss->save(fp);
+ fclose(fp);
+ delete ss;
+ fp = fopen(fname2,"r");
+ ss = static_sequence::load(fp);
+ fclose(fp);
+ delete [] fname2;
+ return ss;*/
+}
+
+static_sequence * savetest(char * bname, static_sequence * ss) {
+ char * fname = new char[10+string(bname).length()];
+ sprintf(fname,"%s.ss",bname);
+ FILE * fp = fopen(fname,"w");
+ cout << "Saving structure ... "; cout.flush();
+ ss->save(fp);
+ cout << "done" << endl; cout.flush();
+ fclose(fp);
+ cout << "Deleting structure ... "; cout.flush();
+ delete ss;
+ cout << "done" << endl; cout.flush();
+ fp = fopen(fname,"r");
+ cout << "Loading structure ... "; cout.flush();
+ ss = static_sequence::load(fp);
+ cout << "done" << endl; cout.flush();
+ fclose(fp);
+ if(ss==NULL) cout << "Error loading static_sequence" << endl;
+ //cout << ss << endl;
+ delete [] fname;
+ return ss;
+}
+
+void speed_rank(static_sequence * ss, uint * text, uint n) {
+ uint max_symbol = 0;
+ for(uint i=0;i<n;i++) {
+ max_symbol = max(max_symbol,text[i]);
+ }
+ max_symbol++;
+ uint *occ = new uint[max_symbol];
+ for(uint i=0;i<max_symbol;i++)
+ occ[i] = 0;
+ for(uint i=0;i<n;i++)
+ occ[text[i]]++;
+
+ uint * valid_symbols = new uint[max_symbol]; uint c=0;
+ for(uint i=0;i<max_symbol;i++) {
+ if(occ[i]>0)
+ valid_symbols[c++]=i;
+ }
+
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint symb = rand()%c;
+ uint pos = rand()%n;
+ acc += ss->rank(valid_symbols[symb],pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " ranks: " << t << " secs" << endl;
+ cout << " * Time per rank: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+ delete [] valid_symbols;
+ delete [] occ;
+}
+
+void speed_select(static_sequence * ss, uint * text, uint n) {
+ uint max_symbol = 0;
+ for(uint i=0;i<n;i++) {
+ max_symbol = max(max_symbol,text[i]);
+ }
+ max_symbol++;
+ uint *occ = new uint[max_symbol];
+ for(uint i=0;i<max_symbol;i++)
+ occ[i] = 0;
+ for(uint i=0;i<n;i++)
+ occ[text[i]]++;
+
+ uint * valid_symbols = new uint[max_symbol]; uint c=0;
+ for(uint i=0;i<max_symbol;i++) {
+ if(occ[i]>0)
+ valid_symbols[c++]=i;
+ }
+
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint symb = rand()%c;
+ uint pos = rand()%occ[valid_symbols[symb]]+1;
+ acc += ss->select(valid_symbols[symb],pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " selects: " << t << " secs" << endl;
+ cout << " * Time per select: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+ delete [] valid_symbols;
+ delete [] occ;
+}
+
+void speed_access(static_sequence * ss, uint * text, uint n) {
+ uint acc=0;
+ srand(SEED);
+
+ start_clock();
+ for(uint i=0;i<NQUERIES;i++) {
+ uint pos = rand()%n;
+ acc += ss->access(pos);
+ }
+ double t = stop_clock();
+ cout << " * Time for " << NQUERIES << " accesses: " << t << " secs" << endl;
+ cout << " * Time per access: " << 1000*t/NQUERIES << " msecs" << endl;
+ cout << " - Check sum: " << acc << endl;
+}
--- /dev/null
+/* static_sequence_tester.h
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_tester
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+
+
+#ifndef STATIC_SEQUENCE_TESTER_H
+#define STATIC_SEQUENCE_TESTER_H
+
+void test_static_sequence(uint * symbols, uint n, static_sequence * ss);
+void load(char *fname, uint ** text, uint * n);
+static_sequence * savetest(char * bname, static_sequence * ss);
+void speed_rank(static_sequence * ss, uint * text, uint n);
+void speed_select(static_sequence * ss, uint * text, uint n);
+void speed_access(static_sequence * ss, uint * text, uint n);
+
+#endif
--- /dev/null
+/* static_sequence_wvtree_noptrs_test.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_wvtree_noptrs_test
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+#include "static_sequence_tester.h"
+
+int main(int argc, char ** argv) {
+ if(argc!=6) {
+ cout << "Usage: " << argv[0] << " <file> <b|r> <c|p> <sampling> <t|s>" << endl;
+ return 0;
+ }
+ stringstream ss;
+ ss << argv[4];
+ uint samp;
+ ss >> samp;
+
+ uint * text;
+ uint n;
+ load(argv[1],&text,&n);
+
+ alphabet_mapper * am;
+
+ static_bitsequence_builder * bmb;
+
+ if(string(argv[2])==string("b"))
+ bmb = new static_bitsequence_builder_brw32(samp);
+ else
+ bmb = new static_bitsequence_builder_rrr02(samp);
+
+ if(string(argv[3])==string("p"))
+ am = new alphabet_mapper_none();
+ else
+ am = new alphabet_mapper_cont(text,n,bmb);
+
+ static_sequence_builder * ssb = new static_sequence_builder_wvtree_noptrs(bmb,am);
+ static_sequence * sseq = ssb->build(text,n);
+
+ delete bmb;
+ delete ssb;
+ sseq = savetest(argv[1], sseq);
+ if(string(argv[5])==string("t"))
+ test_static_sequence(text,n,sseq);
+ else
+ cout << "Size: " << sseq->size() << endl;
+ cout << "*************************************" << endl;
+ speed_access(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_rank(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_select(sseq,text,n);
+
+ delete [] text;
+ delete sseq;
+}
--- /dev/null
+/* static_sequence_wvtree_test.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * static_sequence_wvtree_test
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+#include "static_sequence_tester.h"
+
+int main(int argc, char ** argv) {
+ if(argc!=6) {
+ cout << "Usage: " << argv[0] << " <file> <b|r> <h|p> <sampling> <t|s>" << endl;
+ return 0;
+ }
+ stringstream ss;
+ ss << argv[4];
+ uint samp;
+ ss >> samp;
+
+ uint * text;
+ uint n;
+ load(argv[1],&text,&n);
+
+ alphabet_mapper * am = new alphabet_mapper_none();
+
+ static_bitsequence_builder * bmb;
+ if(string(argv[2])==string("b"))
+ bmb = new static_bitsequence_builder_brw32(samp);
+ else
+ bmb = new static_bitsequence_builder_rrr02(samp);
+
+ wt_coder * wc;
+ if(string(argv[3])==string("p"))
+ wc = new wt_coder_binary(text,n,am);
+ else
+ wc = new wt_coder_huff(text,n,am);
+
+ static_sequence_builder * ssb = new static_sequence_builder_wvtree(wc,bmb,am);
+ static_sequence * sseq = ssb->build(text,n);
+ delete bmb;
+ delete ssb;
+
+ sseq = savetest(argv[1], sseq);
+ if(string(argv[5])==string("t"))
+ test_static_sequence(text,n,sseq);
+ else
+ cout << "Size: " << sseq->size() << endl;
+ cout << "*************************************" << endl;
+ speed_access(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_rank(sseq,text,n);
+ cout << "*************************************" << endl;
+ speed_select(sseq,text,n);
+
+ delete sseq;
+ delete [] text;
+}
+
--- /dev/null
+/* test_to_int.cpp
+ * Copyright (C) 2008, Francisco Claude, all rights reserved.
+ *
+ * text_to_int
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <sys/stat.h>
+#include <iostream>
+#include <sstream>
+#include <basics.h>
+#include <static_bitsequence.h>
+#include <static_bitsequence_builder.h>
+#include <alphabet_mapper.h>
+#include <static_sequence.h>
+#include <static_sequence_builder.h>
+#include "static_sequence_tester.h"
+
+int main(int argc, char ** argv) {
+ if(argc!=3) {
+ cout << "Usage: " << argv[0] << " <file> <output>" << endl;
+ return 0;
+ }
+ char * fname = argv[1];
+ char * oname = argv[2];
+
+ FILE * fp = fopen(fname,"r");
+ if(fp==NULL) {
+ cout << "could not open " << fname << endl;
+ return 1;
+ }
+ struct stat text_info;
+ if(stat(fname,&text_info)<0) {
+ cout << "could not stat: " << fname << endl;
+ return 1;
+ }
+
+ uint n= (uint)text_info.st_size;
+ uint * text = new uint[n];
+
+ for(uint i=0;i<n;i++) {
+ uchar c;
+ fread(&c,sizeof(uchar),1,fp);
+ text[i] = (uint)c;
+ }
+ fclose(fp);
+
+ FILE * out = fopen(oname,"w");
+ if(out==NULL) {
+ cout << "could not open " << oname << endl;
+ return 1;
+ }
+
+ fwrite(text,sizeof(uint),n,out);
+ fclose(out);
+
+ delete [] text;
+ return 0;
+}
+
projects / SXSI / XMLTree.git / commitdiff