Translating Matlab code of vector creation to C++ - c++

Question

I have this Matlab code:
[arr1 arr2 arr3] = fReadFileBin(filename));
Where the body of the functions is :
function [Result1 , Result2 , Result3 ] = fReadFileBin(filename)
fid = fopen(filename, 'r');
fseek(fid, 180, 0);
PV = fread(fid, [A*3 B+2], 'float32');
fclose(fid);
Result1 = PV(1:3:3*A, 2:B+1);
Result1 = Result1';
Result2 = PV(2:3:3*A, 2:B+1);
Result2 = Result2';
Result3 = PV(3:3:3*A, 2:B+1);
Result3 = Result3';
As result I have 3 filled vectors of size BxA and type Double.
When I tried to rewrite it in C++:
std::vector<std::vector<double>> result;
result.resize(B, std::vector<double>(A));
std::ifstream is(filename, std::ios::binary);
is.seekg(0, std::ios_base::end);
std::size_t size = is.tellg();
is.seekg(0, std::ios_base::beg);
is.seekg( 180, 0);
std::vector<double> PV (size / sizeof(double));
if (!is.read((char*)&PV[0], size))
{
throw std::runtime_error("error reading file");
}
// Load the data
is.read((char*)&PV[0], size);
is.close();
// std::vector<double> Result1 =
// std::vector<double> Result2 =
// std::vector<double> Result3 =
//R=R'
//R[j][i] = R[i][j];
This question does make sense for me, but still don't get how I can rewrite this part: (1:3:3*A, 2:B+1) in C++ ?
Notes:
-I'm limited to use only standard libraries (no boost, mmap, etc.).
-I checked Mathwork documentation about colon (and still cannot understand how to implement it).

Answer 1

As the result size of the vectors is fix, I'd rather use std::array:
std::array<std::vector<double>, 3> result;
No resize then any more either, which would have looked much simpler anyway:
//result.resize(B, std::vector<double>(A));
result.resize(3);
With this line, your outer vector now contains exactly three vectors - each of them yet empty - just as with the array approach. Which ever you finally select, you need to resize the inner vectors explicitly then. We'll come back to this later, though.
is.seekg(0, std::ios_base::end);
std::size_t size = is.tellg(); // OK, you fetched file size
//is.seekg(0, std::ios_base::beg); // using beg, you can give the desired offset directly
//is.seekg( 180, 0); // but use the seekdir enum! So:
is.seekg(180, std::ios_base::beg);
However, you should check for the file having at least 180 bytes before. You should be aware that any of these operations might fail, so you should check the stream's state, either after each single operation or at least after several of them in group (so at least before resizing your vector PV). Side note: If the stream is already in fail state, every subsequent operation will fail, too, unless you clear() the error state before.
std::vector<double> PV (size / sizeof(double));
Uh, looks strange to me... You start at offset 180, so I assume you should subtract before division; i. e.:
size_t size = ...;
if(size < 180) // bad file!
{
// throw or whatever appropriate
}
size -= 180;
// go on...
Without this fix, next line would have always resulted in the following exception being thrown because you would have read beyond the end of the file (remember, you started reading from file offset 180!):
if (!is.read((char*)&PV[0], size))
Prefer C++ style casts, though:
if (!is.read(reinterpret_cast<char*>(PV.data()), size))
You'll discover quickly that you need the reinterpret_cast, sometimes appropriate, but should at least ring the alarm bells if you consider using it, in most cases, it is just hiding away some deeper problem such as undefined behaviour. PV.data() exists since C++11 and reads a little easier than &PV[0], but both are equivalent.
However, we now have yet a different issue:
Although the standard does not state anything about precision or even format ("The value representation of floating-point types is implementation-defined."), it is most likely that on your system double is a 64-bit IEEE754 data type. Are you really sure that the data is stored exactly in this format? Only then, this can work at all, still, it is very risky, file producer and consumer could speak different languages and chances are that you get bad input...
Now admitted, I am no matlab expert at all, still the following line of yours lets me doubt strongly that above input format applies:
PV = fread(fid, [A*3 B+2], 'float32');
^^
Finally, you have read your data already within the if clause, so drop this second reading line, it is for nothing but producing another failure...
If now data is not stored in binary, but human readable format, you could read the values in as follows:
std::vector<double> pv; // prefer lower camel case variable names
pv.reserve(size/sizeof(double)); // just using as a size hint;
// we can't deduce number of entries
// from file length exactly any more
double v;
while(is >> v)
{
pv.push_back(v);
}
if(!v.eof())
{
// we did not consume the whole file, so we must
// assume that some input error occurred!
// -> appropriate error handling (throw?)
}
Getting to the end slowly:
// std::vector<double> Result1 =
// std::vector<double> Result2 =
// std::vector<double> Result3 =
Commented out; right, you don't need them, you have them already in the result vector/array, i. e. result[0], result[1] and result[2]...
Resize them (or reserve) as needed to place your result data into and go on.
I am sorry now I am not really aware about what your matlab calculations do and I'm not going to learn matlab for this answer – still, with the hints above you might get along yourself. Just a further hint: you cannot multiply vectors/arrays as a whole with each other or with a scalar directly; you have to do this for each element separately within loops. You might consider std::valarray an interesting alternative, though. Additionally, you might find some interesting stuff in the algorithm library, especially under the section "numeric operations". Feel free to ask another question if you do not get along with these...