← Back to branch summary

~ubuntu-branches/ubuntu/utopic/r-cran-genabel/utopic

« back to all changes in this revision

Viewing changes to src/Transposer.cpp

  • Committer: Package Import Robot
  • Author(s): Andreas Tille, Charles Plessy, Andreas Tille
  • Date: 2014-08-07 17:30:04 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20140807173004-24c20tmrw61yl5dz
Tags: 1.8-0-1
[ Charles Plessy ]
* debian/control: removed myself from Uploaders.

[ Andreas Tille ]
* New upstream version
* Moved debian/upstream to debian/upstream/metadata
* cme fix dpkg-control
* More detailed copyright

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Transposer.cpp
17
17
    process(filename, string(""), false );
18
18
}
19
19
 
20
 
void Transposer::process(string filename, string destFileName, bool forceOverwrite) {
 
20
 
 
21
void Transposer::process(string filename, string destFileName,
 
22
                         bool forceOverwrite) {
21
23
    FileVector* src_fv = new FileVector(filename,1);
22
24
    unsigned long src_nvars = src_fv->getNumVariables();
23
25
    unsigned long src_nobss = src_fv->getNumObservations();
24
26
    unsigned int data_size = src_fv->getElementSize();
25
27
 
26
28
    string dest_file_name;
27
 
    string src_data_file_name; 
28
 
    string dest_data_file_name; 
29
 
    
30
 
    if (destFileName=="") { 
31
 
            // legacy
32
 
        dest_file_name = extract_base_file_name(filename) + "_transposed";
33
 
            src_data_file_name = extract_base_file_name(filename) + FILEVECTOR_DATA_FILE_SUFFIX;
34
 
            dest_data_file_name = extract_base_file_name(filename) + "_transposed" + FILEVECTOR_DATA_FILE_SUFFIX;
 
29
    string src_data_file_name;
 
30
    string dest_data_file_name;
 
31
 
 
32
    if (destFileName == "") {
 
33
        // legacy
 
34
        dest_file_name = extract_base_file_name(filename) + "_transposed";
 
35
        src_data_file_name = extract_base_file_name(filename) +
 
36
            FILEVECTOR_DATA_FILE_SUFFIX;
 
37
        dest_data_file_name = extract_base_file_name(filename) + "_transposed" +
 
38
            FILEVECTOR_DATA_FILE_SUFFIX;
35
39
    } else {
36
 
            dest_file_name = destFileName;   
37
 
            src_data_file_name = filename + FILEVECTOR_DATA_FILE_SUFFIX;
38
 
            dest_data_file_name = destFileName + FILEVECTOR_DATA_FILE_SUFFIX;
 
40
        dest_file_name = destFileName;
 
41
        src_data_file_name = filename + FILEVECTOR_DATA_FILE_SUFFIX;
 
42
        dest_data_file_name = destFileName + FILEVECTOR_DATA_FILE_SUFFIX;
39
43
    }
40
44
 
41
45
 
42
46
    if (!forceOverwrite && headerOrDataExists(dest_file_name)) {
43
 
        errorLog << "File already exists: " << dest_file_name << endl << errorExit;
 
47
        errorLog << "File already exists: " << dest_file_name
 
48
                 << endl << errorExit;
44
49
    }
45
50
 
46
 
    initializeEmptyFile(dest_file_name, src_fv->getNumObservations(), src_fv->getNumVariables(), src_fv->getElementType(),true);
 
51
    initializeEmptyFile(dest_file_name, src_fv->getNumObservations(),
 
52
                        src_fv->getNumVariables(), src_fv->getElementType(),
 
53
                        true);
47
54
 
48
55
    FileVector* dest_fv = new FileVector(dest_file_name,1);
49
56
    dbg << "Copying var/obs names...";
51
58
 
52
59
    delete src_fv;
53
60
    delete dest_fv;
54
 
    dbg << "done"<< endl;
 
61
    dbg << "done" << endl;
55
62
 
56
 
    copy_data(src_data_file_name,dest_data_file_name,src_nvars,src_nobss,data_size);
 
63
    copy_data(src_data_file_name, dest_data_file_name, src_nvars, src_nobss,
 
64
              data_size);
57
65
    dbg << "done"<< endl;
58
66
}
59
67
 
 
68
 
60
69
void Transposer::write_var_obs_names(FileVector *src_fv, FileVector *dest_fv) {
61
 
   // copy observations and variables names
62
 
   for( unsigned long i=0 ; i < src_fv->getNumVariables(); i++ )
63
 
     dest_fv->writeObservationName( i, src_fv->readVariableName(i) );
64
 
 
65
 
   for( unsigned long i=0 ; i < src_fv->getNumObservations(); i++ )
66
 
     dest_fv->writeVariableName( i, src_fv->readObservationName(i) );
67
 
}
68
 
 
69
 
 
70
 
void Transposer::copy_data(string src_data_file_name,string dest_data_file_name, unsigned long src_nvars,
71
 
unsigned long src_nobss, unsigned int data_size) {
72
 
  dbg<< "Copying data..."<< src_nobss << "x"<< src_nvars << endl;
73
 
 
74
 
  unsigned long obs_pages = src_nobss / square_size;
75
 
  if(src_nobss % square_size > 0) obs_pages++;
76
 
 
77
 
  unsigned long var_pages = src_nvars / square_size;
78
 
  if(src_nvars % square_size > 0) var_pages++;
79
 
 
80
 
  ifstream * src_stream = new ifstream();
81
 
  src_stream->open(src_data_file_name.c_str(),ios::in | ios::binary);
82
 
 
83
 
  ofstream * dest_stream = new ofstream;
84
 
  dest_stream->open(dest_data_file_name.c_str(),ios::out | ios::binary);
85
 
 
86
 
  for( unsigned long i =0; i< var_pages;i++) {
87
 
      for( unsigned long j =0; j< obs_pages;j++) {
88
 
          unsigned long obs_length = square_size;
89
 
          if((j + 1 )* square_size > src_nobss)
90
 
              obs_length = src_nobss % square_size;
91
 
 
92
 
          unsigned long var_length = square_size;
93
 
          if((i + 1 )* square_size > src_nvars)
94
 
              var_length = src_nvars % square_size;
95
 
 
96
 
          char * data_part = new (nothrow) char[var_length*obs_length*data_size];
97
 
          if(!data_part) errorLog << "can not allocate memory for data_part" << errorExit;
98
 
          char * data_part_transposed = new (nothrow) char[var_length*obs_length*data_size];
99
 
          if(!data_part_transposed) errorLog << "can not allocate memory for data_part_transposed" << errorExit;
100
 
 
101
 
          read_part(src_stream, data_part, j * square_size , obs_length, i * square_size , var_length,  data_size, src_nobss );
102
 
          transpose_part(data_part,data_part_transposed,obs_length,var_length, data_size);
103
 
          write_part(dest_stream, data_part_transposed, i * square_size, var_length, j* square_size , obs_length,  data_size, src_nvars );
104
 
 
105
 
          delete[] data_part;
106
 
          delete[] data_part_transposed;
107
 
      }
108
 
      dbg << endl;
109
 
  }
110
 
 
111
 
  src_stream->close();
112
 
  delete src_stream;
113
 
  dest_stream->close();
114
 
  delete dest_stream;
115
 
 
116
 
  dbg<< "data written" << endl;
117
 
}
118
 
 
119
 
 
120
 
/*
121
 
* read next piece of data with size = obs_length x var_length, starting from var_start, obs_start coordinates
122
 
*/
123
 
void Transposer::read_part(ifstream * src_stream, char * data_part, unsigned long obs_start , unsigned long obs_length,
124
 
unsigned long var_start, unsigned long var_length , unsigned int  data_size, unsigned long src_obs_length ) {
125
 
        for(unsigned long i=0; i<var_length ;i++) {
126
 
           //seek to the beginning of the next var
127
 
           unsigned long read_pos =   (var_start + i )* src_obs_length  + obs_start ;
128
 
           src_stream->seekg( read_pos * data_size , ios::beg );
129
 
           //read next var to input buffer
130
 
           src_stream->read( data_part + ( i * obs_length * data_size ), obs_length * data_size );
131
 
        }
132
 
}
133
 
 
134
 
/*
135
 
* write next piece of transposed data with size = obs_length' x var_length'
136
 
*/
137
 
void Transposer::write_part(ofstream * dest_stream, char * data_part_transposed, unsigned long obs_start , unsigned long obs_length,
138
 
unsigned long var_start, unsigned long var_length , unsigned int  data_size, unsigned long dest_obs_length ) {
139
 
        for(unsigned long i=0; i<var_length ;i++) {
140
 
           //seek to the beginning of the next var
141
 
           unsigned long write_pos =   (var_start + i )* dest_obs_length  + obs_start ;
142
 
           dest_stream->seekp( write_pos * data_size , ios::beg );
143
 
           //write next piece of var to file
144
 
           dest_stream->write( data_part_transposed + ( i * obs_length * data_size ), obs_length * data_size );
145
 
        }
146
 
}
147
 
 
148
 
/*
149
 
* transpose piece of data to write to the new file.
150
 
* original axb matrix flipped to bxa matrix.
151
 
*/
 
70
    // copy observations and variables names
 
71
    for (unsigned long i = 0 ; i < src_fv->getNumVariables(); i++ )
 
72
        dest_fv->writeObservationName( i, src_fv->readVariableName(i) );
 
73
 
 
74
    for (unsigned long i = 0 ; i < src_fv->getNumObservations(); i++ )
 
75
        dest_fv->writeVariableName( i, src_fv->readObservationName(i) );
 
76
}
 
77
 
 
78
 
 
79
void Transposer::copy_data(string src_data_file_name, string dest_data_file_name,
 
80
                           unsigned long src_nvars, unsigned long src_nobss,
 
81
                           unsigned int data_size) {
 
82
    dbg << "Copying data..." << src_nobss << "x" << src_nvars << endl;
 
83
 
 
84
    unsigned long obs_pages = src_nobss / square_size;
 
85
    if (src_nobss % square_size > 0) obs_pages++;
 
86
 
 
87
    unsigned long var_pages = src_nvars / square_size;
 
88
    if (src_nvars % square_size > 0) var_pages++;
 
89
 
 
90
    ifstream * src_stream = new ifstream();
 
91
    src_stream->open(src_data_file_name.c_str(),ios::in | ios::binary);
 
92
 
 
93
    ofstream * dest_stream = new ofstream;
 
94
    dest_stream->open(dest_data_file_name.c_str(),ios::out | ios::binary);
 
95
 
 
96
    for (unsigned long i = 0; i < var_pages; i++) {
 
97
        for (unsigned long j = 0; j< obs_pages; j++) {
 
98
            unsigned long obs_length = square_size;
 
99
            if ((j + 1 ) * square_size > src_nobss)
 
100
                obs_length = src_nobss % square_size;
 
101
 
 
102
            unsigned long var_length = square_size;
 
103
            if ((i + 1 ) * square_size > src_nvars)
 
104
                var_length = src_nvars % square_size;
 
105
 
 
106
            char * data_part =
 
107
                new (nothrow) char[var_length*obs_length*data_size];
 
108
            if (!data_part)
 
109
                errorLog << "can not allocate memory for data_part"
 
110
                         << errorExit;
 
111
 
 
112
            char * data_part_transposed =
 
113
                new (nothrow) char[var_length*obs_length*data_size];
 
114
            if (!data_part_transposed)
 
115
                errorLog << "can not allocate memory for data_part_transposed"
 
116
                         << errorExit;
 
117
 
 
118
            read_part(src_stream, data_part, j * square_size ,
 
119
                      obs_length, i * square_size , var_length,
 
120
                      data_size, src_nobss);
 
121
            transpose_part(data_part, data_part_transposed, obs_length,
 
122
                           var_length, data_size);
 
123
            write_part(dest_stream, data_part_transposed, i * square_size,
 
124
                       var_length, j * square_size, obs_length,
 
125
                       data_size, src_nvars);
 
126
 
 
127
            delete[] data_part;
 
128
            delete[] data_part_transposed;
 
129
        }
 
130
        dbg << endl;
 
131
    }
 
132
 
 
133
    src_stream->close();
 
134
    delete src_stream;
 
135
    dest_stream->close();
 
136
    delete dest_stream;
 
137
 
 
138
    dbg << "data written" << endl;
 
139
}
 
140
 
 
141
 
 
142
/*
 
143
 * read next piece of data with size = obs_length x var_length,
 
144
 * starting from var_start, obs_start coordinates
 
145
 */
 
146
void Transposer::read_part(ifstream * src_stream, char * data_part,
 
147
                           unsigned long obs_start, unsigned long obs_length,
 
148
                           unsigned long var_start, unsigned long var_length,
 
149
                           unsigned int  data_size,
 
150
                           unsigned long src_obs_length) {
 
151
    for (unsigned long i = 0; i < var_length; i++) {
 
152
        //seek to the beginning of the next var
 
153
        unsigned long read_pos = (var_start + i ) * src_obs_length + obs_start;
 
154
        src_stream->seekg(read_pos * data_size, ios::beg);
 
155
        //read next var to input buffer
 
156
        src_stream->read(data_part + ( i * obs_length * data_size ),
 
157
                         obs_length * data_size );
 
158
    }
 
159
}
 
160
 
 
161
 
 
162
/*
 
163
 * write next piece of transposed data with size = obs_length' x var_length'
 
164
 */
 
165
void Transposer::write_part(ofstream * dest_stream, char * data_part_transposed,
 
166
                            unsigned long obs_start, unsigned long obs_length,
 
167
                            unsigned long var_start, unsigned long var_length,
 
168
                            unsigned int  data_size,
 
169
                            unsigned long dest_obs_length) {
 
170
    for (unsigned long i = 0; i < var_length; i++) {
 
171
        // seek to the beginning of the next var
 
172
        unsigned long write_pos = (var_start + i ) * dest_obs_length + obs_start;
 
173
        dest_stream->seekp(write_pos * data_size, ios::beg);
 
174
        // write next piece of var to file
 
175
        dest_stream->write(data_part_transposed + (i * obs_length * data_size),
 
176
                           obs_length * data_size );
 
177
    }
 
178
}
 
179
 
 
180
 
 
181
/*
 
182
 * transpose piece of data to write to the new file.
 
183
 * original axb matrix flipped to bxa matrix.
 
184
 */
152
185
void Transposer::transpose_part(void * data_part, void * data_part_transposed,
153
 
unsigned long obs_length,unsigned long var_length, unsigned int data_size ) {
154
 
        for(unsigned long i=0; i<var_length ;i++) {
155
 
                for(unsigned long j=0; j<obs_length ;j++) {
156
 
           int from_pos =  (i * obs_length + j )* data_size;
157
 
           int to_pos = ( j * var_length  + i ) * data_size;
158
 
                   memcpy((char*)data_part_transposed + to_pos,
159
 
                          (char*)data_part + from_pos,
160
 
                          data_size);
161
 
                }
162
 
        }
 
186
                                unsigned long obs_length,
 
187
                                unsigned long var_length,
 
188
                                unsigned int data_size) {
 
189
    for (unsigned long i = 0; i < var_length; i++) {
 
190
        for(unsigned long j = 0; j < obs_length; j++) {
 
191
            int from_pos = (i * obs_length + j ) * data_size;
 
192
            int to_pos = ( j * var_length  + i ) * data_size;
 
193
            memcpy((char*)data_part_transposed + to_pos,
 
194
                   (char*)data_part + from_pos,
 
195
                   data_size);
 
196
        }
 
197
    }
163
198
}