Function af_approx1_common

src/api/c/approx.cpp:48–114

}

void af_approx1_common(af_array *yo, const af_array yi, const af_array xo,
                       const int xdim, const double xi_beg,
                       const double xi_step, const af_interp_type method,
                       const float offGrid, const bool allocate_yo) {
    ARG_ASSERT(0, yo != 0);  // *yo (the af_array) can be null, but not yo
    ARG_ASSERT(1, yi != 0);
    ARG_ASSERT(2, xo != 0);

    const ArrayInfo &yi_info = getInfo(yi);
    const ArrayInfo &xo_info = getInfo(xo);

    const dim4 &yi_dims = yi_info.dims();
    const dim4 &xo_dims = xo_info.dims();
    dim4 yo_dims        = yi_dims;
    yo_dims[xdim]       = xo_dims[xdim];

    ARG_ASSERT(1, yi_info.isFloating());      // Only floating and complex types
    ARG_ASSERT(2, xo_info.isRealFloating());  // Only floating types
    ARG_ASSERT(1, yi_info.isSingle() ==
                      xo_info.isSingle());  // Must have same precision
    ARG_ASSERT(1, yi_info.isDouble() ==
                      xo_info.isDouble());  // Must have same precision
    ARG_ASSERT(3, xdim >= 0 && xdim < 4);

    // POS should either be (x, 1, 1, 1) or (1, yi_dims[1], yi_dims[2],
    // yi_dims[3])
    if (xo_dims[xdim] != xo_dims.elements()) {
        for (int i = 0; i < 4; i++) {
            if (xdim != i) { DIM_ASSERT(2, xo_dims[i] == yi_dims[i]); }
        }
    }

    ARG_ASSERT(5, xi_step != 0);
    ARG_ASSERT(
        6, (method == AF_INTERP_CUBIC || method == AF_INTERP_CUBIC_SPLINE ||
            method == AF_INTERP_LINEAR || method == AF_INTERP_LINEAR_COSINE ||
            method == AF_INTERP_LOWER || method == AF_INTERP_NEAREST));

    if (yi_dims.ndims() == 0 || xo_dims.ndims() == 0) {
        af_create_handle(yo, 0, nullptr, yi_info.getType());
        return;
    }

    if (allocate_yo) { *yo = createHandle(yo_dims, yi_info.getType()); }

    DIM_ASSERT(0, getInfo(*yo).dims() == yo_dims);

    switch (yi_info.getType()) {
        case f32:
            approx1<float, float>(yo, yi, xo, xdim, xi_beg, xi_step, method,
                                  offGrid);
            break;
        case f64:
            approx1<double, double>(yo, yi, xo, xdim, xi_beg, xi_step, method,
                                    offGrid);
            break;
        case c32:
            approx1<cfloat, float>(yo, yi, xo, xdim, xi_beg, xi_step, method,