Destructuring field binding

Add DestructuringBindingsForFieldClass to use pystencils kernels in a more C++-ish way

DestructuringBindingsForFieldClass defines all field-related variables in its subordinated block. However, it leaves a TypedSymbol of type Field for each field undefined. By that trick we can generate kernels that accept structs as kernelparameters. Either to include a pystencils specific Field struct of the following definition:

template<DTYPE_T, DIMENSION>
struct Field
{
    DTYPE_T* data;
    std::array<int64_t, DIMENSION> shape;
    std::array<int64_t, DIMENSION> stride;
}

or to be able to destructure user defined types like pybind11::array, at::Tensor, tensorflow::Tensor.

The test generates a kernel like that:

FUNC_PREFIX void kernel(Field<double, 2>& x, Field<double, 2>& y, Field<double, 2>& z)
{
   _stride_z_1 = z.stride[1];
   _size_x_0 = x.shape[0];
   _stride_x_1 = x.stride[1];
   _stride_z_0 = z.stride[0];
   _size_x_1 = x.shape[1];
   _stride_y_1 = y.stride[1];
   _data_x = x.data;
   _stride_x_0 = x.stride[0];
   _data_z = z.data;
   _stride_y_0 = y.stride[0];
   _data_y = y.data;
   {
      for (int ctr_0 = 0; ctr_0 < _size_x_0; ctr_0 += 1)
      {
         double * RESTRICT _data_z_00 = _data_z + _stride_z_0*ctr_0;
         double * RESTRICT const _data_y_00 = _data_y + _stride_y_0*ctr_0;
         double * RESTRICT const _data_x_00 = _data_x + _stride_x_0*ctr_0;
         for (int ctr_1 = 0; ctr_1 < _size_x_1; ctr_1 += 1)
         {
            _data_z_00[_stride_z_1*ctr_1] = log(_data_x_00[_stride_x_1*ctr_1]*_data_y_00[_stride_y_1*ctr_1])*_data_y_00[_stride_y_1*ctr_1];
         }
      }
   }
}

pystencils/astnodes.py

 from typing import Any, List, Optional, Sequence, Set, Union
 
+import jinja2
 import sympy as sp
 
 from pystencils.data_types import TypedSymbol, cast_func, create_type
@@ -661,7 +662,12 @@ class DestructuringBindingsForFieldClass(Node):
         FieldShapeSymbol: "shape",
         FieldStrideSymbol: "stride"
     }
-    CLASS_NAME = "Field"
+    CLASS_NAME_TEMPLATE = jinja2.Template("Field<{{ dtype }}, {{ ndim }}>")
+
+    @property
+    def fields_accessed(self) -> Set['ResolvedFieldAccess']:
+        """Set of Field instances: fields which are accessed inside this kernel function"""
+        return set(o.field for o in self.atoms(ResolvedFieldAccess))
 
     def __init__(self, body):
         super(DestructuringBindingsForFieldClass, self).__init__()
@@ -682,10 +688,12 @@ class DestructuringBindingsForFieldClass(Node):
 
     @property
     def undefined_symbols(self) -> Set[sp.Symbol]:
+        field_map = {f.name: f for f in self.fields_accessed}
         undefined_field_symbols = self.symbols_defined
         corresponding_field_names = {s.field_name for s in undefined_field_symbols if hasattr(s, 'field_name')}
         corresponding_field_names |= {s.field_names[0] for s in undefined_field_symbols if hasattr(s, 'field_names')}
-        return {TypedSymbol(f, self.CLASS_NAME + '&') for f in corresponding_field_names} | \
+        return {TypedSymbol(f, self.CLASS_NAME_TEMPLATE.render(dtype=field_map[f].dtype, ndim=field_map[f].ndim) + '&')
+                for f in corresponding_field_names} | \
             (self.body.undefined_symbols - undefined_field_symbols)
 
     def subs(self, subs_dict) -> None: