function stridedSlice_(x, begin, end, strides, beginMask = 0, endMask = 0, ellipsisMask = 0, newAxisMask = 0, shrinkAxisMask = 0) {
    let $x = convertToTensor(x, 'x', 'stridedSlice');
    const forward = (backend) => {
        if (strides == null) {
            strides = new Array(begin.length);
        }
        const ellipsisAxes = maskToAxes(ellipsisMask);
        if (ellipsisAxes.length > 1) {
            throw new Error('Multiple ellipses in slice is not allowed.');
        }
        if (ellipsisMask !== 0 && newAxisMask !== 0) {
            throw new Error('Using both ellipsisMask and newAxisMask is not yet supported.');
        }
        if (ellipsisMask !== 0 && shrinkAxisMask !== 0) {
            throw new Error('Using both ellipsisMask and shrinkAxisMask is not yet supported.');
        }
        const numInterpolatedAxes = $x.rank - begin.length;
        // Expand the dims of x based on the newAxisMask.
        const expandAxes = maskToAxes(newAxisMask);
        const newShape = $x.shape.slice();
        expandAxes.forEach(axis => {
            begin[axis] = 0;
            end[axis] = 1;
            newShape.splice(axis, 0, 1);
        });
        $x = reshape($x, newShape);
        const { begin: normalizedBegin, end: normalizedEnd, strides: normalizedStrides } = getNormalizedAxes($x.shape, ellipsisAxes, numInterpolatedAxes, begin, end, strides, beginMask, endMask, ellipsisMask);
        begin = normalizedBegin;
        end = normalizedEnd;
        strides = normalizedStrides;
        const shrinkAxes = maskToAxes(shrinkAxisMask);
        // Adjust the ends based on the shrink mask.
        shrinkAxes.forEach(axis => {
            end[axis] = begin[axis] + 1;
            strides[axis] = 1;
        });
        // Figure out the output shape.
        const size = computeOutShape(begin, end, strides);
        // Remove the axes based on shrinkMask.
        const outShape = size.filter((_, axis) => shrinkAxes.indexOf(axis) === -1);
        const nonStrided = strides.every(v => v === 1);
        if (nonStrided) {
            return reshape(slice($x, begin, size), outShape);
        }
        const res = backend.stridedSlice($x, begin, end, strides);
        return reshape(res, outShape);
    };
    const inputs = { x: $x };
    const attrs = {
        begin,
        end,
        strides,
        beginMask,
        endMask,
        ellipsisMask,
        newAxisMask,
        shrinkAxisMask
    };
    return ENGINE.runKernelFunc(forward, inputs, null /* grad */, StridedSlice, attrs);
}
/**
 * Extracts a strided slice of a tensor.
 *
 * Roughly speaking, this op extracts a slice of size (end-begin)/stride from
 * the given input tensor (x). Starting at the location specified by begin the
 * slice continues by adding stride to the index until all dimensions are not
 * less than end. Note that a stride can be negative, which causes a reverse
 * slice.
 *
 * ```js
 * const t = tf.tensor3d([1, 1, 1 ,2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6],
 *    [3, 2, 3]);
 * t.stridedSlice([1, 0, 0], [2, 1, 3], [1, 1, 1]).print()  // [[[3, 3, 3]]]
 * t.stridedSlice([1, 0, 0], [2, 2, 3], [1, 1, 1]).print()  // [[[3, 3, 3],
 *                                                     // [4, 4, 4]]]
 * t.stridedSlice([1, -1, 0], [2, -3, 3], [1, -1, 1]).print() // [[[4, 4, 4],
 *                                                     // [3, 3, 3]]]
 * ```
 *
 * @param x The tensor to stride slice.
 * @param begin The coordinates to start the slice from.
 * @param end: The coordinates to end the slice at.
 * @param strides: The size of the slice.
 * @param beginMask: If the ith bit of beginMask is set, begin[i] is ignored
 *      and the fullest possible range in that dimension is used instead.
 * @param endMask: If the ith bit of endMask is set, end[i] is ignored
 *      and the fullest possible range in that dimension is used instead.
 * @param shrinkAxisMask: a bitmask where bit i implies that
 * the ith specification should shrink the dimensionality. begin and end must
 * imply a slice of size 1 in the dimension.
 *
 * @doc {heading: 'Operations', subheading: 'Slicing and Joining'}
 */
Extracts a strided slice of a tensor.
Roughly speaking, this op extracts a slice of size (end-begin)/stride from
the given input tensor (x). Starting at the location specified by begin the
slice continues by adding stride to the index until all dimensions are not
less than end. Note that a stride can be negative, which causes a reverse
slice.



@param x The tensor to stride slice.
@param begin The coordinates to start the slice from.
@param end: The coordinates to end the slice at.
@param strides: The size of the slice.
@param beginMask: If the ith bit of beginMask is set, begin[i] is ignored
and the fullest possible range in that dimension is used instead.
@param endMask: If the ith bit of endMask is set, end[i] is ignored
and the fullest possible range in that dimension is used instead.
@param shrinkAxisMask: a bitmask where bit i implies that
the ith specification should shrink the dimensionality. begin and end must
imply a slice of size 1 in the dimension.

@doc {heading: 'Operations', subheading: 'Slicing and Joining'}
Extracts a strided slice of a tensor . Roughly speaking this op extracts a slice of size ( end - begin ) / stride from the given input tensor ( x ) . Starting at the location specified by begin the slice continues by adding stride to the index until all dimensions are not less than end . Note that a stride can be negative which causes a reverse slice . @param x The tensor to stride slice . @param begin The coordinates to start the slice from . @param end : The coordinates to end the slice at . @param strides : The size of the slice . @param beginMask : If the ith bit of beginMask is set begin [ i ] is ignored and the fullest possible range in that dimension is used instead . @param endMask : If the ith bit of endMask is set end [ i ] is ignored and the fullest possible range in that dimension is used instead . @param shrinkAxisMask : a bitmask where bit i implies that the ith specification should shrink the dimensionality . begin and end must imply a slice of size 1 in the dimension . @doc { heading : ' Operations ' subheading : ' Slicing and Joining ' }
function stridedSlice_(x, begin, end, strides, beginMask = 0, endMask = 0, ellipsisMask = 0, newAxisMask = 0, shrinkAxisMask = 0) {
    let $x = convertToTensor(x, 'x', 'stridedSlice');
    const forward = (backend) => {
        if (strides == null) {
            strides = new Array(begin.length);
        }
        const ellipsisAxes = maskToAxes(ellipsisMask);
        if (ellipsisAxes.length > 1) {
            throw new Error('Multiple ellipses in slice is not allowed.');
        }
        if (ellipsisMask !== 0 && newAxisMask !== 0) {
            throw new Error('Using both ellipsisMask and newAxisMask is not yet supported.');
        }
        if (ellipsisMask !== 0 && shrinkAxisMask !== 0) {
            throw new Error('Using both ellipsisMask and shrinkAxisMask is not yet supported.');
        }
        const numInterpolatedAxes = $x.rank - begin.length;
        const expandAxes = maskToAxes(newAxisMask);
        const newShape = $x.shape.slice();
        expandAxes.forEach(axis => {
            begin[axis] = 0;
            end[axis] = 1;
            newShape.splice(axis, 0, 1);
        });
        $x = reshape($x, newShape);
        const { begin: normalizedBegin, end: normalizedEnd, strides: normalizedStrides } = getNormalizedAxes($x.shape, ellipsisAxes, numInterpolatedAxes, begin, end, strides, beginMask, endMask, ellipsisMask);
        begin = normalizedBegin;
        end = normalizedEnd;
        strides = normalizedStrides;
        const shrinkAxes = maskToAxes(shrinkAxisMask);
        shrinkAxes.forEach(axis => {
            end[axis] = begin[axis] + 1;
            strides[axis] = 1;
        });
        const size = computeOutShape(begin, end, strides);
        const outShape = size.filter((_, axis) => shrinkAxes.indexOf(axis) === -1);
        const nonStrided = strides.every(v => v === 1);
        if (nonStrided) {
            return reshape(slice($x, begin, size), outShape);
        }
        const res = backend.stridedSlice($x, begin, end, strides);
        return reshape(res, outShape);
    };
    const inputs = { x: $x };
    const attrs = {
        begin,
        end,
        strides,
        beginMask,
        endMask,
        ellipsisMask,
        newAxisMask,
        shrinkAxisMask
    };
    return ENGINE.runKernelFunc(forward, inputs, null , StridedSlice, attrs);
}
function stridedSlice_ ( x , begin , end , strides , beginMask = 0 , endMask = 0 , ellipsisMask = 0 , newAxisMask = 0 , shrinkAxisMask = 0 ) { let $x = convertToTensor ( x , 'x' , 'stridedSlice' ) ; const forward = ( backend ) => { if ( strides == null ) { strides = new Array ( begin . length ) ; } const ellipsisAxes = maskToAxes ( ellipsisMask ) ; if ( ellipsisAxes . length > 1 ) { throw new Error ( 'Multiple ellipses in slice is not allowed.' ) ; } if ( ellipsisMask !== 0 && newAxisMask !== 0 ) { throw new Error ( 'Using both ellipsisMask and newAxisMask is not yet supported.' ) ; } if ( ellipsisMask !== 0 && shrinkAxisMask !== 0 ) { throw new Error ( 'Using both ellipsisMask and shrinkAxisMask is not yet supported.' ) ; } const numInterpolatedAxes = $x . rank - begin . length ; const expandAxes = maskToAxes ( newAxisMask ) ; const newShape = $x . shape . slice ( ) ; expandAxes . forEach ( axis => { begin [ axis ] = 0 ; end [ axis ] = 1 ; newShape . splice ( axis , 0 , 1 ) ; } ) ; $x = reshape ( $x , newShape ) ; const { begin : normalizedBegin , end : normalizedEnd , strides : normalizedStrides } = getNormalizedAxes ( $x . shape , ellipsisAxes , numInterpolatedAxes , begin , end , strides , beginMask , endMask , ellipsisMask ) ; begin = normalizedBegin ; end = normalizedEnd ; strides = normalizedStrides ; const shrinkAxes = maskToAxes ( shrinkAxisMask ) ; shrinkAxes . forEach ( axis => { end [ axis ] = begin [ axis ] + 1 ; strides [ axis ] = 1 ; } ) ; const size = computeOutShape ( begin , end , strides ) ; const outShape = size . filter ( ( _ , axis ) => shrinkAxes . indexOf ( axis ) === - 1 ) ; const nonStrided = strides . every ( v => v === 1 ) ; if ( nonStrided ) { return reshape ( slice ( $x , begin , size ) , outShape ) ; } const res = backend . stridedSlice ( $x , begin , end , strides ) ; return reshape ( res , outShape ) ; } ; const inputs = { x : $x } ; const attrs = { begin , end , strides , beginMask , endMask , ellipsisMask , newAxisMask , shrinkAxisMask } ; return ENGINE . runKernelFunc ( forward , inputs , null , StridedSlice , attrs ) ; }
Extracts a strided slice of a tensor.
Extracts a strided slice of a tensor .
// Expand the dims of x based on the newAxisMask. // Adjust the ends based on the shrink mask. // Figure out the output shape. // Remove the axes based on shrinkMask. /* grad */