Can we use function call operator for indexing instead of at?

[bassoy]

Right now index accessing is performed using the at member function in tensor e.g. in tensor_dynamic, see also in example.

for(auto i = 0u; i < B.size(0); ++i)
  for(auto j = 0u; j < B.size(1); ++j)
        C.at(i,j) = std::conj(B.at(i,j));

Is it possible to overload operator() for this purpose? Note that operator() will also be used for creating subtensors.

for(auto i = 0u; i < B.size(0); ++i)
  for(auto j = 0u; j < B.size(1); ++j)
        C(i,j) = std::conj(B(i,j));

We could also use operator[] for accessing single indices and multi-indices.

for(auto i = 0u; i < B.size(0); ++i)
  for(auto j = 0u; j < B.size(1); ++j)
        C[i,j] = std::conj(B[i,j]);

This will be again closer to a Matlab or Octave or R notation.

[amitsingh19975]

I think we should follow what the C++ standard does with the subscript operator(operator[]) and method at.

The subscript operator does not check bounds, but, on the other hand, method at does. The user can opt-in for themselves if they want performance over safety. In most cases, people choose C++ for performance, and it can quench the thirst for speed.

In our case, operator[] maps to operator().

     C.at(1,1) = 3; // bound checked
     C(1,1) = 3; // no bound checked; equivalent to C[i]

This kind of optimization could be very helpful inside a hot loop. Otherwise, we have to incur the cost of a bound check that is very bad for high-performant code.

[bassoy]

The question is for me. Do we want bound checks for a member function as in std::vector
The std::vector needs to be generic. However, our tensor must not be that generic.

I propose :

• tensor::operator[] for single-index access without bound check
• tensor::operator() for multi-index access without bound check
• at(tensor, multi-index) as free function with bound check

[bassoy]

This has the charm that tensor methods are fast per nature!

[amitsingh19975]

Yes, I agree with this proposal.