Why NDArray is faster than int32NDArray?

[John W. Eaton]

On 26-Jul-2011, Hamid 2C wrote:

| > On 26 July 2011 13:35, Hamid 2C <address@hidden> wrote:
| >> I have coded two different version of array multiplication in C++
| >> using Octave library.
| >
| > src plz
| >
| // mymultreal.cpp where NDArray is used.
| #include <octave/oct.h>
| #include <iostream>
| #include <cstdlib>
| DEFUN_DLD (mymultreal, args, nargout, "") {
| octave_value_list retval;
| 
|    NDArray x=args(0).array_value();
|    NDArray y=args(1).array_value();
|    int d1x = x.rows();
|    int d2x = x.columns();
|    int d1y = y.rows();
|    int d2y = y.columns();
|    if ((d2x != d1y)) {
|        std::cout<<"error"<<"incompatible dimensions"<<"\n";return retval;
|    }
|    NDArray z(dim_vector( d1x,  d2y));
|    int i;
|    int j;
|    int k;
|    for (i = (0); i <= (d1x - 1); i += (1)) {
|        for (j = (0); j <= (d2y - 1); j += (1)) {
|            z.xelem(i, j) = 0;
|            for (k = (0); k <= (d1y - 1); k += (1)) {
|                z.xelem(i, j) = z.xelem(i, j) + x.xelem(i, k) * y.xelem(k, j);
|            }
|        }
|    }
|    retval(0) = z;
|    return retval;
| }
| 
| //mymult.cpp
| #include <octave/oct.h>
| #include <iostream>
| #include <cstdlib>
| DEFUN_DLD (mymult, args, nargout, "") {
| octave_value_list retval;
| 
|    int32NDArray x=args(0).int32_array_value();
|    int32NDArray y=args(1).int32_array_value();
|    int d1x = x.rows();
|    int d2x = x.columns();
|    int d1y = y.rows();
|    int d2y = y.columns();
|    if ((d2x != d1y)) {
|        std::cout<<"error"<<"incompatible dimensions"<<"\n";return retval;
|    }
|    int32NDArray z(dim_vector( d1x,  d2y));
|    int i;
|    int j;
|    int k;
|    for (i = (0); i <= (d1x - 1); i += (1)) {
|        for (j = (0); j <= (d2y - 1); j += (1)) {
|            z.xelem(i, j) = 0;
|            for (k = (0); k <= (d1y - 1); k += (1)) {
|                z.xelem(i, j) = z.xelem(i, j) + x.xelem(i, k) * y.xelem(k, j);
|            }
|        }
|    }
|    retval(0) = z;
|    return retval;
| }

The data for an NDArray object is stored in an array of native double
values.

Because of the semantics of integer operations that Octave must
implement for compatibility with Matlab, the data for an int32NDArray
object is stored as an array of octave_int32 objects.  The
multiplication and addition operators for octave_int32 objects must do
more than just multiply integer values.  They must also handle the
saturation semantics of Matlab's integer types.

If you want to use native integer multiplication with wrapping
semantics, you'll have to do something different.

jwe