Problem with C++ operator for Vector

[Toto]

Hello,
I've got a problem with the redefinition of operator in C++. My intent
is to create a TVector that internally work with __int64, with an
external interface of double in order to optimize the operations. The
double value put in input should be muliplied with factor 1e10, in
order to limit
the loss of precision and divided with the same quantity in output.
To make this, I've supposed to can modify the operator() for the access
at the singular element of a Vector.
My test Vector class is like this

class Vector
{
private:
__int64 *Array;
public:
inline __int64& TVector:perator()(byte Index) {if(Index>FDim) throw
Exception("Out of bound Exception");return
(__int64)Array[Index]*1e10;};
};

In the program:
double Value = 3.43;
Vector V(3);
V(1) = Value:// Internally V.Array[1] =3.43e10;
V(1)=V(1)+1;
Value = V(1); // Value=4.43;


Obviously the adopted solution does not work as I hope. Please, could
someone help me with any kind of advise? I hope to have explain in good
way the problem.
Thanks in advance.

 

[Victor Bazarov]

I've got a problem with the redefinition of operator in C++. My intent
is to create a TVector that internally work with __int64, with an
external interface of double in order to optimize the operations. The
double value put in input should be muliplied with factor 1e10, in
order to limit
the loss of precision and divided with the same quantity in output.
To make this, I've supposed to can modify the operator() for the
access at the singular element of a Vector.
My test Vector class is like this

class Vector
{
private:
__int64 *Array;
public:
inline __int64& TVector:perator()(byte Index) {if(Index>FDim) throw
Exception("Out of bound Exception");return
(__int64)Array[Index]*1e10;};

You can't expect it to work on the left side of an assignment operator.
You need something else there. Since you cannot expose the contents of
your 'Array' to the user (as you tried), you need to write proxy classes,
which will have assignment from a double expression and the conversion
from 'double':

struct proxy {
__int64& lvalue;
proxy(__int64& lv) : lvalue(lv) {}
void operator = (double d) {
lvalue = d * 1e10;
}
operator double () {
return lvalue / 1e10;
}
};

struct const_proxy {
__int64 lvalue;
const_proxy(__int64 lv) : lvalue(lv) {}
operator double () {
return lvalue / 1e10;
}
};

and make your Vector return an instance of 'proxy':

const_proxy operator()(byte Index) const {
if (Index >= FDim) throw Exception("...");
return const_proxy(Array[Index]);
}

proxy operator()(byte Index) {
if (Index >= FDim) throw Exception("...");
return proxy(Array[Index]);
}

};

In the program:
double Value = 3.43;
Vector V(3);
V(1) = Value:// Internally V.Array[1] =3.43e10;
V(1)=V(1)+1;
Value = V(1); // Value=4.43;


Obviously the adopted solution does not work as I hope. Please, could
someone help me with any kind of advise? I hope to have explain in
good way the problem.

You have. Now I hope I have explained the solution well.

V

 

[Markus Becker]

Hi,

I've got a problem with the redefinition of operator in C++. My intent
is to create a TVector that internally work with __int64, with an
external interface of double in order to optimize the operations. The
double value put in input should be muliplied with factor 1e10, in
order to limit
the loss of precision and divided with the same quantity in output.

1) you'll still lose a lot of precision, depending on the range of
the numbers you want to store. Especially if they differ by more
than a factor of 1e10
2) Do you really think that an __int64-wrapper class will perform
better than native CPU's doubles?

Markus, not much help with your prblem, I know ;-)

 

[Toto]

Thank you very much for your help. Now I'm trying your solution and
after I check whether it works.

 

[Toto]

Dear Victor,
I have tried your solution. It works very well!! It's wonderful!!!

However I have encountered a little problem. Please read the example:

void Function(void)
{
double Value = 0;
Vector V(3);
Vector V2(3);

V(3) = 3; //OK
Value = V(3); //OK
V(2) = V(3); //OK
V2(1) = V(3); //Error Message: Compiler could not generate operator=
for class proxy
}

Please, could you help me to understand the Error of the last case? In
my point of view the lasts two code rows are similar, because in both
cases there are 2 assignment from element of Vector. Thanks in advance.



Other question: I would like to implement this solution in order to
speed up my mathematical libraries. Could anyone suggest me a website
(or similar thinks) which contains
sourcecode (for example written in assembler) that implements
operations with Matrix
and Vector? Thanks a lot.

 

[Victor Bazarov]

Dear Victor,
I have tried your solution. It works very well!! It's wonderful!!!

However I have encountered a little problem. Please read the example:

void Function(void)
{
double Value = 0;
Vector V(3);
Vector V2(3);

V(3) = 3; //OK
Value = V(3); //OK
V(2) = V(3); //OK
V2(1) = V(3); //Error Message: Compiler could not generate operator=
for class proxy
}

Please, could you help me to understand the Error of the last case? In
my point of view the lasts two code rows are similar, because in both
cases there are 2 assignment from element of Vector. Thanks in
advance.

The problem is that the proxy class contains a reference. The compiler
cannot guess whether you mean to re-seat a reference or assign the value
when performing operator==, and that's a guess at this point. Implement
your own operator== in the proxy class and do what's right.

Other question: I would like to implement this solution in order to
speed up my mathematical libraries. Could anyone suggest me a website
(or similar thinks) which contains
sourcecode (for example written in assembler) that implements
operations with Matrix
and Vector? Thanks a lot.

I don't know of any website with those things, but I strongly recommend
putting aside performance for now. Only optimize what you know is not
optimal. And you can only know by measuring. There are whole books
written on optimization and performance, perhaps you need to check them
out... "Efficient C++" is one of them. D. Knuth's "The Art of Computer
Programming" is a classic, of course.

V