Arithmetic operations on NumericArrays

Question

Currently, NumericArrays are directly supported by the most important array-related functions, what makes them a very attractive data structure for implementing highly efficient algorithms. Here is a (possibly incomplete) list of functions from the current Documentation which directly support NumericArrays as input and output data structure:

Part, Take, Drop, Flatten, Join, FunctionCompile, NetEncoder.

Other functions which directly support NumericArrays according to the Documentation include:

Dimensions, Length, ArrayDepth, NumericArrayQ, NumericArrayType, Normal, Image, Image3D, Audio.

Testing shows that Total also accepts NumericArray as input:

Total[NumericArray[{1, 2, 3}, "UnsignedInteger8"]]

6

But what is missing is the support even for the basic arithmetic operations on NumericArrays. For example, an attempt to add two arrays of the same type and shape returns unevaluated:

NumericArray[{1, 2, 3}, "UnsignedInteger8"] + NumericArray[{3, 4, 5}, "UnsignedInteger8"]

There is undocumented built-in package "NumericArrayUtilities`" with the Description

Utilities for doing high-performance numeric computations.

It includes several utilities:

Needs["NumericArrayUtilities`"]
Names["NumericArrayUtilities`*"] // Length

38

But it seems they don't offer the desired functionality either.

My question:

How can I perform basic arithmetic operations on NumericArrays without converting them to usual arrays?

I'm most interested in subtraction and addition.

Answer 1

It seems like no one answered this yet, so let me elaborate a little on my comment. A simple example of using FunctionCompile to add NumericArrays would be:

n1 = NumericArray[{1, 2, 3}, "UnsignedInteger8"];
n2 = NumericArray[{3, 4, 5}, "UnsignedInteger8"];
add = FunctionCompile[
   Function[
    {
     Typed[x, TypeSpecifier["NumericArray"]["UnsignedInteger8", 1]],
     Typed[y, TypeSpecifier["NumericArray"]["UnsignedInteger8", 1]]
     },
    x + y
    ]
   ];
add[n1, n2]
Normal[%]

{4, 6, 8}

So as you can see, this is a bit tedious because you need to define a new function for each type of array. I believe that there is work ongoing in the compiler team to have polymorphic types that would make this easier, but for the time being you can do something like:

Clear[addArrays];
addArrays[type_String, depth_Integer] := (
   addArrays[type, depth] = FunctionCompile[
     Function[
      {
       Typed[x, TypeSpecifier["NumericArray"][type, depth]],
       Typed[y, TypeSpecifier["NumericArray"][type, depth]]
       },
      x + y
      ]
     ]
   );
addArrays[n1_?NumericArrayQ, n2_?NumericArrayQ] := With[{
   types = NumericArrayType /@ {n1, n2},
   depths = ArrayDepth /@ {n1, n2}
   },
  If[And[SameQ @@ types, SameQ @@ depths],
   addArrays[types[[1]], depths[[1]]][n1, n2]
   ]
  ];

addArrays[NumericArray[{1, 2}, "UnsignedInteger64"], NumericArray[{2, 2}, "UnsignedInteger64"]]

Answer 2

I don't have anything to add with respect to arithmetic on the NumericArray objects, which I feel Sjoerd covered well with their answer, but since OP asked about the package, I thought I would add this.

The functions inside the NumericArrayUtilities` package AFAIK are helper functions that are primarily of use to those developing new machine learning functionality and applications.

To see a list:

?NumericArrayUtilities`*

Doing this for any package will produce a nicely formatted grid of clickable links for each function in the package, that will (depending on output format!) look something like:

InformationDataGrid[{
    "ctx`" -> {
        "ctx`myFunctionName, ...
}}, ___]

if you are in input form, something slightly more terse in full form, or in a notebook,

Caveat: YMMV with subpackages and namespaces, etc... Grepping the function names in certain packages will also produce output that is extremely voluminous.