docs: public static int cudnnBatchNormalizationForwardTraining(
          cudnnHandle handle, 
          int mode, 
          Pointer alpha, /** alpha[0] = result blend factor */
          Pointer beta, /** beta[0] = dest layer blend factor */
          cudnnTensorDescriptor xDesc, 
          Pointer x, /** NxCxHxW */
          cudnnTensorDescriptor yDesc, 
          Pointer y, /** NxCxHxW */
          /**
           * <pre>
           * Shared desc for the next 6 tensors in the argument list.
                 Data type to be set as follows:
                 type = (typeOf(x) == double) ? double : float
                 Dimensions for this descriptor depend on normalization mode
                 - Spatial Normalization : tensors are expected to have dims 1xCx1x1
                  (normalization is performed across NxHxW)
                 - Per-Activation Normalization : tensors are expected to have dims of 1xCxHxW
           * (normalization is performed across N)
           * </pre>
           */
          cudnnTensorDescriptor bnScaleBiasMeanVarDesc, 
          /** 'Gamma' and 'Beta' respectively in Ioffe and Szegedy's paper's notation */
          Pointer bnScale, 
          Pointer bnBias, 
          /**
           * <pre>
           * MUST use factor=1 in the very first call of a complete training cycle.
                 Use a factor=1/(1+n) at N-th call to the function to get
                 Cumulative Moving Average (CMA) behavior
                 CMA[n] = (x[1]+...+x[n])/n
                 Since CMA[n+1] = (n*CMA[n]+x[n+1])/(n+1) =
                 ((n+1)*CMA[n]-CMA[n])/(n+1) + x[n+1]/(n+1) =
           * CMA[n]*(1-1/(n+1)) + x[n+1]*1/(n+1)
           * </pre>
           */
          double exponentialAverageFactor, 
          /** Used in Training phase only.
                 runningMean = newMean*factor + runningMean*(1-factor) */
          Pointer resultRunningMean, 
          /** Output in training mode, input in inference. Is the moving average
                 of  variance[x] (factor is applied in the same way as for runningMean) */
          Pointer resultRunningVariance, 
          /** Has to be >= CUDNN_BN_MIN_EPSILON. Should be the same in forward and backward functions. */
          double epsilon, 
          /** Optionally save intermediate results from the forward pass here
                 - can be reused to speed up backward pass. NULL if unused */
          Pointer resultSaveMean, 
          Pointer resultSaveInvVariance)
      {
          return checkResult(cudnnBatchNormalizationForwardTrainingNative(handle, mode, alpha, beta, xDesc, x, yDesc, y, bnScaleBiasMeanVarDesc, bnScale, bnBias, exponentialAverageFactor, resultRunningMean, resultRunningVariance, epsilon, resultSaveMean, resultSaveInvVariance));
      }