function y = mean(x,dim,flag,flag2)

%MEAN   Average or mean value.

%   S = MEAN(X) is the mean value of the elements in X if X is a vector. 

%   For matrices, S is a row vector containing the mean value of each 

%   column. 

%   For N-D arrays, S is the mean value of the elements along the first 

%   array dimension whose size does not equal 1.

%

%   MEAN(X,'all') is the mean of all elements in X.

%

%   MEAN(X,DIM) takes the mean along the dimension DIM of X.

%

%   MEAN(X,VECDIM) operates on the dimensions specified in the vector 

%   VECDIM. For example, MEAN(X,[1 2]) operates on the elements contained

%   in the first and second dimensions of X.

%

%   S = MEAN(...,TYPE) specifies the type in which the mean is performed, 

%   and the type of S. Available options are:

%

%   'double'    -  S has class double for any input X

%   'native'    -  S has the same class as X

%   'default'   -  If X is floating point, that is double or single,

%                  S has the same class as X. If X is not floating point, 

%                  S has class double.

%

%   S = MEAN(...,NANFLAG) specifies how NaN (Not-A-Number) values are 

%   treated. The default is 'includenan':

%

%   'includenan' - the mean of a vector containing NaN values is also NaN.

%   'omitnan'    - the mean of a vector containing NaN values is the mean 

%                  of all its non-NaN elements. If all elements are NaN,

%                  the result is NaN.

%

%   Example:

%       X = [1 2 3; 3 3 6; 4 6 8; 4 7 7]

%       mean(X,1)

%       mean(X,2)

%

%   Class support for input X:

%      float: double, single

%      integer: uint8, int8, uint16, int16, uint32,

%               int32, uint64, int64

%

%   See also MEDIAN, STD, MIN, MAX, VAR, COV, MODE.

%   Copyright 1984-2018 The MathWorks, Inc.

isDimSet = nargin > 1 && ((~ischar(dim) && ~(isstring(dim) && isscalar(dim))) || ... 

    (~isInvalidText(dim) && strncmpi(dim,'all',max(strlength(dim), 1))));

isFlag2Set = nargin >= 4; 

if nargin == 1 || (nargin == 2 && isDimSet) 

    flag = 'default'; 

    omitnan = false; 

else % nargin >= 3 || (nargin == 2 && ~isDimSet)

    if nargin == 2

        flag = dim;

    elseif nargin == 3

        if ~isDimSet

            flag2 = dim;

            isFlag2Set = true;

        end

    elseif nargin == 4 && ~isDimSet

        error(message('MATLAB:mean:nonNumericSecondInput'));

    end

    if ~isFlag2Set

        flag2 = '';

    end

    [flag, omitnan] = parseInputs(flag, flag2, isFlag2Set);

end 

if ~isDimSet 

    % preserve backward compatibility with 0x0 empty

    if isequal(x,[]) 

        y = sum(x,flag)./0;

        return

    end

    dim = find(size(x)~=1,1); 

    if isempty(dim) 

        dim = 1;

    end

else

    if isempty(dim)

        error(message('MATLAB:mean:nonNumericSecondInput'));

    end

end 

if ~isobject(x) && isinteger(x) 

    % accumulation flag may still be partial

    isnative = strncmpi(flag, 'native', max(1, strlength(flag)));

    if intmin(class(x)) == 0  % unsigned integers

        y = sum(x,dim,flag);

        if (isnative && all(y(:) < intmax(class(x)))) || ...

                (~isnative && all(y(:) <= flintmax))

            % no precision lost, can use the sum result

            y = y./mysize(x,dim);

        else  % throw away and recompute

            y = intmean(x,dim,isnative);

        end

    else  % signed integers

        ypos = sum(max(x,0),dim,flag);

        yneg = sum(min(x,0),dim,flag);

        if (isnative && all(ypos(:) < intmax(class(x))) && ...

                all(yneg(:) > intmin(class(x)))) || ...

                (~isnative && all(ypos(:) <= flintmax) && ...

                all(yneg(:) >= -flintmax))

            % no precision lost, can use the sum result

            y = (ypos+yneg)./mysize(x,dim);

        else  % throw away and recompute

            y = intmean(x,dim,isnative);

        end

    end

else 

    if omitnan      

        % Compute sum and number of NaNs

        m = sum(x, dim, flag, 'omitnan');

        nr_nonnan = mysize(x, dim) - matlab.internal.math.countnan(x, dim);

        % Divide by the number of non-NaNs.

        y = m ./ nr_nonnan;

    else 

        y = sum(x, dim, flag) ./ mysize(x,dim); 

    end 

end 

end